open-multi-agent-kit 0.79.3 → 0.80.2

package/dist/orchestration/evidence-gate.js

@@ -262,6 +262,15 @@ export function compressDiagnostic(command, exitCode, stdout, stderr) {
 /** Allowlist pattern reused from quality-gate.ts */
 const SCRIPT_NAME_PATTERN = /^[A-Za-z0-9:_-]+$/;
 const PACKAGE_MANAGERS = new Set(["npm", "pnpm", "yarn", "bun"]);
+/**
+ * Agent-freedom mode (e.g. SWE-bench / DeepSWE) relaxes command-pass gate
+ * allowlisting so agents can run arbitrary test/build/lint commands.
+ */
+function isStrictGuardrailMode() {
+    const raw = process.env.OMK_STRICT_GUARDRAIL ?? "";
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "on";
+}
 export const SUMMARY_ALIASES = [
     "## Summary",
     "## Evidence",
@@ -279,6 +288,9 @@ export const SUMMARY_ALIASES = [
 function resolveSafeCommand(command) {
     const trimmed = command.trim();
     const parts = trimmed.split(/\s+/);
+    if (!isStrictGuardrailMode()) {
+        return { cmd: parts[0], args: parts.slice(1) };
+    }
     if (parts.length === 1 && SCRIPT_NAME_PATTERN.test(parts[0])) {
         return { cmd: "npm", args: ["run", parts[0]] };
     }

package/dist/orchestration/executor.js

@@ -5,6 +5,7 @@ import { estimateRunProgress } from "./eta.js";
 import { dagNodeRoutingEnv } from "./routing.js";
 import { getOmkResourceSettings } from "../util/resource-profile.js";
 import { checkEvidenceGates } from "./evidence-gate.js";
+import { checkEvidenceGate } from "../runtime/contracts/evidence.js";
 import { invalidateTaskDagGraph } from "./task-graph.js";
 import { resolveTimeoutMs } from "../util/timeout-config.js";
 import { createNodeMonitorEngine } from "./node-monitor.js";
@@ -318,46 +319,141 @@ export function createExecutor(executorOptions = {}) {
         }
     }
     async function checkNodeEvidence(node, result, options) {
-        const gates = [];
+        const cwd = options.worktreeRoot ?? process.cwd();
+        const latestAttempt = node.attempts?.[node.attempts.length - 1];
+        const attemptId = latestAttempt ? `${node.id}__${latestAttempt.attempt}` : `${node.id}__1`;
+        const required = nodeRequiresEvidence(node);
+        const bridge = await legacyEvidenceBridge(node, result, { cwd, runId: options.runId, attemptId, required });
+        const metadata = {
+            ...(result.metadata ?? {}),
+            ...(bridge.evidenceGates.length > 0 && { evidenceGates: bridge.evidenceGates }),
+            ...(bridge.diffObserved && { diff: true }),
+        };
+        const check = checkEvidenceGate(required, node.outputs, metadata, result.stdout, bridge.artifactPaths);
+        return {
+            passed: check.satisfied,
+            evidence: evidenceGateCheckToDagEvidence(check, bridge.evidence),
+        };
+    }
+    async function legacyEvidenceBridge(node, result, options) {
+        const legacyGates = [];
         for (const output of node.outputs ?? []) {
             switch (output.gate) {
                 case "file-exists":
+                case "artifact":
                     if (output.ref)
-                        gates.push({ type: "file-exists", path: output.ref });
+                        legacyGates.push({ type: "file-exists", path: output.ref });
                     break;
                 case "test-pass":
-                    gates.push({ type: "command-pass", command: output.ref ?? "npm test" });
+                    legacyGates.push({ type: "command-pass", command: output.ref ?? "npm test" });
                     break;
                 case "command-pass":
-                    gates.push({ type: "command-pass", command: output.ref ?? "" });
+                    legacyGates.push({ type: "command-pass", command: output.ref ?? "" });
+                    break;
+                case "diff":
+                    legacyGates.push({ type: "diff-nonempty" });
                     break;
                 case "review-pass":
                 case "summary":
-                    gates.push({ type: "summary-present", summaryMarker: output.ref ?? "## Summary" });
+                    legacyGates.push({ type: "summary-present", summaryMarker: output.ref ?? "## Summary" });
                     break;
                 case "none":
                 default:
                     break;
             }
         }
-        const hasCommandGate = (node.outputs ?? []).some((o) => o.gate === "command-pass" || o.gate === "test-pass");
-        if (node.routing?.evidenceRequired && !hasCommandGate) {
-            gates.push({ type: "summary-present", summaryMarker: "## Evidence" });
+        if (options.required && node.routing?.evidenceRequired && !legacyGates.some((gate) => gate.type === "command-pass")) {
+            legacyGates.push({ type: "summary-present", summaryMarker: "## Evidence" });
         }
-        if (gates.length === 0) {
-            return { passed: true, evidence: [] };
+        if (legacyGates.length === 0) {
+            return { evidenceGates: [], artifactPaths: [], diffObserved: false, evidence: [] };
         }
-        const latestAttempt = node.attempts?.[node.attempts.length - 1];
-        const attemptId = latestAttempt ? `${node.id}__${latestAttempt.attempt}` : `${node.id}__1`;
-        return checkEvidenceGates(gates, {
-            cwd: options.worktreeRoot ?? process.cwd(),
+        const legacy = await checkEvidenceGates(legacyGates, {
+            cwd: options.cwd,
             stdout: result.stdout,
             nodeId: node.id,
             runId: options.runId,
-            attemptId,
+            attemptId: options.attemptId,
         });
+        const evidenceGates = [];
+        const artifactPaths = [];
+        let diffObserved = false;
+        for (const item of legacy.evidence) {
+            if (!item.passed)
+                continue;
+            if (item.gate === "command-pass")
+                evidenceGates.push("command-pass");
+            else if (item.gate === "summary-present")
+                evidenceGates.push("summary");
+            else if (item.gate === "file-exists") {
+                evidenceGates.push("artifact");
+                if (item.ref)
+                    artifactPaths.push(item.ref);
+            }
+            else if (item.gate === "diff-nonempty") {
+                evidenceGates.push("diff");
+                diffObserved = true;
+            }
+        }
+        return { evidenceGates, artifactPaths, diffObserved, evidence: legacy.evidence };
+    }
+    function evidenceGateCheckToDagEvidence(check, bridgeEvidence) {
+        const evidence = [...bridgeEvidence];
+        for (const observation of check.observations ?? []) {
+            evidence.push({
+                gate: observation.kind,
+                passed: check.satisfied,
+                ref: observation.ref ?? observation.artifactPath,
+                message: `Evidence observation ${observation.kind} from ${observation.source} confidence=${observation.confidence}`,
+            });
+        }
+        for (const missing of check.missing) {
+            evidence.push({
+                gate: missing,
+                passed: false,
+                failureKind: "missing-evidence-observation",
+                message: check.reason,
+            });
+        }
+        return evidence;
+    }
+    function hasRequiredEvidenceOutput(node) {
+        return (node.outputs ?? []).some((output) => output.required !== false && output.gate !== undefined && output.gate !== "none");
+    }
+    function nodeRequiresEvidence(node) {
+        const highRisk = nodeHasHighRiskCapabilities(node);
+        const outputs = node.outputs ?? [];
+        const explicitlyNoEvidence = outputs.length > 0 && outputs.every((output) => output.required === false || output.gate === undefined || output.gate === "none");
+        if (explicitlyNoEvidence && !highRisk)
+            return false;
+        return hasRequiredEvidenceOutput(node) || highRisk;
+    }
+    function nodeHasHighRiskCapabilities(node) {
+        return node.routing?.assignedProviderCapabilities?.some((cap) => ["write", "patch", "shell", "merge"].includes(cap)) ?? false;
     }
     async function runNode(node, dag, runner, options, state, signal, outAbort) {
+        if (nodeRequiresEvidence(node)) {
+            const hasGate = (node.outputs ?? []).some((output) => ["file-exists", "test-pass", "review-pass", "command-pass", "summary", "artifact", "diff"].includes(output.gate ?? ""));
+            if (!hasGate) {
+                scheduler.updateNodeStatus(dag, node.id, "failed", options.runId);
+                markNodeStarted(node);
+                const completedAt = new Date().toISOString();
+                const startedAtMs = Date.parse(node.startedAt ?? completedAt);
+                const durationMs = Math.max(0, Date.parse(completedAt) - startedAtMs);
+                const latestAttempt = { attempt: node.retries + 1, startedAt: node.startedAt ?? completedAt, completedAt, durationMs, status: "failed", error: "[omk] Evidence gate required but missing: high-risk node has no command-pass, test-pass, review-pass, file-exists, or summary output gate" };
+                node.attempts = [...(node.attempts ?? []), latestAttempt];
+                node.evidence = [
+                    ...(node.evidence ?? []),
+                    { gate: "evidence-required", passed: false, message: latestAttempt.error, failureKind: "missing-evidence-gate" },
+                ];
+                markNodeFinished(node, "failed");
+                refreshState(state, dag, options);
+                await commitState(state);
+                emit(cloneState(state));
+                emitTelemetry({ type: "lane.failed", runId: options.runId, nodeId: node.id, laneId: node.id, status: "failed", data: { success: false, exitCode: 78 } });
+                return;
+            }
+        }
         scheduler.updateNodeStatus(dag, node.id, "running", options.runId);
         markNodeStarted(node);
         bumpActivity(state);

package/dist/orchestration/loop-controller-headroom.d.ts

@@ -0,0 +1,6 @@
+import type { EvaluateLoopDecisionInput, LoopDecision } from "./loop-state.js";
+import type { HeadroomDecisionHistoryEntry } from "../runtime/headroom-loop-risk.js";
+export interface HeadroomAwareLoopControllerInput extends EvaluateLoopDecisionInput {
+    readonly headroomHistory: readonly HeadroomDecisionHistoryEntry[];
+}
+export declare function evaluateHeadroomAwareLoopController(input: HeadroomAwareLoopControllerInput): LoopDecision;

package/dist/orchestration/loop-controller-headroom.js

@@ -0,0 +1,33 @@
+import { evaluateLoopDecision } from "./loop-controller.js";
+import { evaluateHeadroomAwareLoopDecision } from "../runtime/headroom-aware-loop-decision.js";
+function toHeadroomAction(action) {
+    switch (action) {
+        case "close":
+            return "continue";
+        case "verify-only":
+            return "continue";
+        case "handoff":
+            return "block";
+        default:
+            return action;
+    }
+}
+export function evaluateHeadroomAwareLoopController(input) {
+    const baseDecision = evaluateLoopDecision(input);
+    const headroomAware = evaluateHeadroomAwareLoopDecision({
+        baseAction: toHeadroomAction(baseDecision.action),
+        baseReason: baseDecision.reason,
+        baseConfidence: baseDecision.confidence,
+        headroomHistory: input.headroomHistory,
+    });
+    return {
+        ...baseDecision,
+        action: headroomAware.action === "context-adjustment" ? "continue" : headroomAware.action,
+        reason: headroomAware.reason,
+        confidence: headroomAware.confidence,
+        risk: {
+            ...baseDecision.risk,
+            headroom: headroomAware.risk?.headroom,
+        },
+    };
+}

package/dist/orchestration/scheduler.d.ts

@@ -1,6 +1,8 @@
 import type { Dag, DagNode, TaskStatus } from "./dag.js";
+import type { RunnableNodePlan } from "./task-graph.js";
 export interface Scheduler {
     getRunnableNodes(dag: Dag): DagNode[];
+    getRunnablePlan(dag: Dag): RunnableNodePlan[];
     updateNodeStatus(dag: Dag, id: string, status: TaskStatus, runId?: string): void;
     isComplete(dag: Dag): boolean;
     isFailed(dag: Dag): boolean;

package/dist/orchestration/scheduler.js

@@ -6,6 +6,9 @@ export function createScheduler() {
         getRunnableNodes(dag) {
             return getTaskDagGraph(dag).runnableNodes().slice();
         },
+        getRunnablePlan(dag) {
+            return getTaskDagGraph(dag).runnablePlan();
+        },
         updateNodeStatus(dag, id, status, runId) {
             const node = getTaskDagGraph(dag).getNode(id);
             if (!node)

package/dist/orchestration/task-graph.d.ts

@@ -1,4 +1,17 @@
 import { type Dag, type DagNode } from "./dag.js";
+export interface RunnableNodePlan {
+    readonly node: DagNode;
+    readonly nodeId: string;
+    readonly rank: number;
+    readonly score: number;
+    readonly criticalPathDepth: number;
+    readonly downstreamCount: number;
+    readonly priority: number;
+    readonly cost: number;
+    readonly evidenceProducer: boolean;
+    readonly evidenceRequired: boolean;
+    readonly reason: string;
+}
 export declare class TaskDagGraph {
     private readonly nodeById;
     private readonly predecessorIds;
@@ -19,8 +32,12 @@ export declare class TaskDagGraph {
     findCycle(): string[];
     findAllCycles(limit?: number): string[][];
     getCriticalPathDepth(id: string): number;
+    getDownstreamCount(id: string): number;
+    getRunnableScore(id: string): number;
+    runnablePlan(): RunnableNodePlan[];
     private compareOrder;
     private compareRunnable;
+    private describeRunnableNode;
     private runnableScore;
     private criticalPathDepth;
     private downstreamCount;

package/dist/orchestration/task-graph.js

@@ -190,12 +190,50 @@ export class TaskDagGraph {
     getCriticalPathDepth(id) {
         return this.criticalPathDepth(id);
     }
+    getDownstreamCount(id) {
+        return this.downstreamCount(id);
+    }
+    getRunnableScore(id) {
+        return this.runnableScore(id);
+    }
+    runnablePlan() {
+        return this.runnableNodes().map((node, index) => this.describeRunnableNode(node, index));
+    }
     compareOrder(a, b) {
         return (this.order.get(a) ?? 0) - (this.order.get(b) ?? 0);
     }
     compareRunnable(a, b) {
         return this.runnableScore(b) - this.runnableScore(a) || this.compareOrder(a, b);
     }
+    describeRunnableNode(node, index) {
+        const criticalPathDepth = this.criticalPathDepth(node.id);
+        const downstreamCount = this.downstreamCount(node.id);
+        const evidenceProducer = (node.outputs ?? []).some((output) => output.gate && output.gate !== "none");
+        const evidenceRequired = node.routing?.evidenceRequired === true;
+        const priority = Number.isFinite(node.priority) ? node.priority ?? 0 : 0;
+        const cost = node.cost ?? 1;
+        const score = this.runnableScore(node.id);
+        return {
+            node,
+            nodeId: node.id,
+            rank: index + 1,
+            score,
+            criticalPathDepth,
+            downstreamCount,
+            priority,
+            cost,
+            evidenceProducer,
+            evidenceRequired,
+            reason: [
+                `criticalDepth=${criticalPathDepth}`,
+                `downstream=${downstreamCount}`,
+                `priority=${priority}`,
+                `cost=${cost}`,
+                evidenceProducer ? "evidenceProducer" : "noEvidenceGate",
+                evidenceRequired ? "evidenceRequired" : "evidenceOptional",
+            ].join("; "),
+        };
+    }
     runnableScore(id) {
         const node = this.nodeById.get(id);
         if (!node)

package/dist/providers/codex-cli-runner.js

@@ -56,8 +56,8 @@ export function createCodexCliAdvisoryTaskRunner(options) {
                     };
                 }
                 const prompt = preflight.input;
-                const sandboxMode = risk === "read" || advisoryMode ? "read-only" : "workspace-write";
-                const approvalPolicy = sandboxMode === "workspace-write" ? "on-request" : "never";
+                const sandboxMode = resolveCodexCliSandboxMode(risk, advisoryMode, env);
+                const approvalPolicy = codexCliApprovalPolicy(env.OMK_APPROVAL_POLICY ?? env.OMK_EXECUTION, sandboxMode);
                 const childEnv = buildChildEnv({
                     overrideEnv: {
                         ...env,
@@ -101,6 +101,21 @@ export function createCodexCliAdvisoryTaskRunner(options) {
     };
     return runner;
 }
+function resolveCodexCliSandboxMode(risk, advisoryMode, env) {
+    if (risk === "read" || advisoryMode)
+        return "read-only";
+    if (env.OMK_PROVIDER_AUTHORITY === "advisory")
+        return "read-only";
+    return "workspace-write";
+}
+function codexCliApprovalPolicy(value, sandboxMode) {
+    if (sandboxMode !== "read-only")
+        return "on-request";
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "never" || normalized === "yolo")
+        return "never";
+    return "on-request";
+}
 function buildCodexPrompt(node, env) {
     return [
         "You are a Codex CLI advisory/read-only lane inside OMK.",

package/dist/runtime/agent-runtime.d.ts

@@ -5,7 +5,7 @@
  */
 import type { TaskResult } from "../contracts/orchestration.js";
 import type { ContextCapsule } from "./context-capsule.js";
-import type { RuntimeCapabilities as SharedRuntimeCapabilities, RuntimeHealth as SharedRuntimeHealth, RuntimeId, RuntimeKind } from "./contracts/shared.js";
+import type { RuntimeCapabilities as SharedRuntimeCapabilities, RuntimeHealth as SharedRuntimeHealth, RuntimeHealthProbeRequest, RuntimeId, RuntimeKind } from "./contracts/shared.js";
 export type { RuntimeAuthority, RuntimeId, RuntimeKind } from "./contracts/shared.js";
 export interface TokenUsage {
     readonly inputTokens: number;
@@ -58,6 +58,29 @@ export interface ToolManifest {
     readonly skills?: readonly string[];
     readonly hooks?: readonly string[];
 }
+export interface AgentTaskSafety {
+    readonly risk: string;
+    readonly riskTrace?: unknown;
+    readonly approvalPolicy: string;
+    readonly sandboxMode: string;
+    readonly evidenceRequired: boolean;
+    readonly authorityMode: string;
+}
+export interface AgentTaskSovereignty {
+    readonly mode: "freedomd" | "standard";
+    readonly dataBoundary: "public" | "internal" | "customer" | "secret";
+    readonly retentionDecision: "allow" | "redact" | "downgrade" | "block";
+    readonly jurisdictionDecision: "allow" | "downgrade" | "block";
+    readonly providerCutoffRisk: number;
+    readonly localFallbackAvailable: boolean;
+    readonly reason: string;
+}
+export interface AgentContextCompaction {
+    readonly schemaVersion: "omk.task-compaction.v1";
+    readonly contract: unknown;
+    readonly diagnostics: Readonly<Record<string, unknown>>;
+    readonly artifactRef?: string;
+}
 export interface AgentContext {
     readonly runId: string;
     readonly nodeId: string;
@@ -72,6 +95,9 @@ export interface AgentContext {
     }>;
     readonly goalContext?: unknown;
     readonly workerManifest?: unknown;
+    readonly compaction?: AgentContextCompaction;
+    /** Freedomd sovereignty decision surfaced to runtime adapters. */
+    readonly sovereignty?: AgentTaskSovereignty;
     readonly abortSignal?: AbortSignal;
     readonly cwd?: string;
     readonly env?: Record<string, string>;
@@ -105,8 +131,11 @@ export interface AgentTask {
     readonly tools: ToolManifest;
     readonly providerPolicy: ProviderPolicy;
     readonly capabilities: CapabilityManifest;
+    readonly safety: AgentTaskSafety;
     /** Images/files attached to this task (clipboard paste, --image, drag). */
     readonly attachments?: readonly AgentTaskAttachment[];
+    /** Freedomd sovereignty decision attached by retention/jurisdiction gates. */
+    readonly sovereignty?: AgentTaskSovereignty;
 }
 export interface AgentResult {
     readonly output: string;
@@ -122,11 +151,11 @@ export interface AgentRuntime {
     readonly displayName?: string;
     readonly kind?: RuntimeKind;
     readonly legacy?: boolean;
-    readonly runtimeMode?: string;
+    readonly runtimeMode: string;
     readonly priority: number;
     readonly capabilities?: RuntimeCapabilities;
     supports(capsule: ContextCapsule): boolean;
-    health?(): Promise<RuntimeHealth>;
+    health?(input?: RuntimeHealthProbeRequest): Promise<RuntimeHealth>;
     runNode(capsule: ContextCapsule, signal: AbortSignal): Promise<AgentRunResult>;
     execute?(task: AgentTask): Promise<AgentResult>;
 }

package/dist/runtime/agent-runtime.js

@@ -3,16 +3,29 @@
  *
  * Each runtime wraps a specific Kimi/provider invocation mode.
  */
+import { sanitizeRuntimeStderrResult } from "./private-stderr.js";
 export function toTaskResult(result) {
+    const runtimeId = typeof result.metadata?.selectedRuntime === "string"
+        ? result.metadata.selectedRuntime
+        : typeof result.metadata?.runtime === "string"
+            ? result.metadata.runtime
+            : undefined;
+    const sanitized = sanitizeRuntimeStderrResult(result, {
+        runId: typeof result.metadata?.runId === "string" ? result.metadata.runId : process.env.OMK_RUN_ID,
+        nodeId: typeof result.metadata?.nodeId === "string" ? result.metadata.nodeId : process.env.OMK_NODE_ID,
+        runtimeId,
+        root: process.env.OMK_PROJECT_ROOT ?? process.cwd(),
+        env: process.env,
+    });
     return {
-        success: result.success,
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
+        success: sanitized.success,
+        exitCode: sanitized.exitCode,
+        stdout: sanitized.stdout,
+        stderr: sanitized.stderr,
         metadata: {
-            ...result.metadata,
-            ...(result.tokenUsage != null && { tokenUsage: result.tokenUsage }),
-            ...(result.toolCalls != null && result.toolCalls.length > 0 && { toolCalls: result.toolCalls }),
+            ...sanitized.metadata,
+            ...(sanitized.tokenUsage != null && { tokenUsage: sanitized.tokenUsage }),
+            ...(sanitized.toolCalls != null && sanitized.toolCalls.length > 0 && { toolCalls: sanitized.toolCalls }),
         },
     };
 }

package/dist/runtime/authority-matrix.d.ts

@@ -0,0 +1,23 @@
+import type { AgentRuntime, AgentTask } from "./agent-runtime.js";
+export type RuntimeMode = "api" | "cli" | "wire" | "mcp" | "local" | "composite" | string;
+export type AuthorityOperation = "read" | "review" | "write" | "patch" | "shell" | "mcp" | "merge" | "vision" | "toolCalling";
+export interface RuntimeAuthorityMatrixEntry {
+    readonly providerId: string;
+    readonly runtimeMode: RuntimeMode;
+    readonly authorities: readonly AuthorityOperation[];
+    readonly advisory: boolean;
+    readonly notes?: string;
+}
+export declare const RUNTIME_AUTHORITY_MATRIX: readonly RuntimeAuthorityMatrixEntry[];
+export declare function runtimeProviderId(runtime: Pick<AgentRuntime, "providerId" | "id">): string;
+export declare function runtimeModeOf(runtime: Pick<AgentRuntime, "runtimeMode" | "kind" | "id">): RuntimeMode;
+export declare function getRuntimeAuthorityEntry(runtime: Pick<AgentRuntime, "providerId" | "runtimeMode" | "kind" | "id">): RuntimeAuthorityMatrixEntry | undefined;
+export declare function authoritiesForRuntime(runtime: Pick<AgentRuntime, "providerId" | "runtimeMode" | "kind" | "id" | "capabilities">): readonly AuthorityOperation[];
+export declare function runtimeIsAdvisory(runtime: Pick<AgentRuntime, "providerId" | "runtimeMode" | "kind" | "id" | "capabilities">): boolean;
+export declare function requiredAuthorityForTask(task: Pick<AgentTask, "capabilities">): readonly AuthorityOperation[];
+export declare function runtimeSatisfiesAuthority(runtime: AgentRuntime, task: AgentTask): {
+    ok: boolean;
+    missing: readonly AuthorityOperation[];
+    reason?: string;
+};
+export declare function authorityCapableProviderIds(required: readonly AuthorityOperation[]): string[];