open-multi-agent-kit 0.79.3 → 0.80.0

package/dist/runtime/chat-advisory-runtime.js

@@ -2,6 +2,9 @@ import { execSync } from "child_process";
 export function createChatAdvisoryRuntime() {
     return {
         id: "omk-advisory",
+        providerId: "omk",
+        runtimeMode: "local",
+        kind: "local",
         priority: 0,
         supports: () => true,
         async runNode(_capsule, _signal) {

package/dist/runtime/codex-cli-runtime.js

@@ -6,6 +6,8 @@ export function createCodexCliRuntime(options) {
     const runner = createCodexCliAdvisoryTaskRunner(options);
     return {
         id: "codex-cli",
+        providerId: "codex",
+        runtimeMode: "cli",
         displayName: "Codex CLI",
         kind: "cli",
         priority: 60,

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

@@ -4,6 +4,7 @@
  * Spawns the `codex` CLI subprocess and bridges AgentTask / AgentResult.
  */
 import type { AgentRuntime, AgentRunResult, AgentResult, AgentTask, RuntimeCapabilities, RuntimeHealth } from "./agent-runtime.js";
+import type { RuntimeHealthProbeRequest } from "./contracts/shared.js";
 import type { ContextCapsule } from "./context-capsule.js";
 export interface CodexRuntimeOptions {
     bin?: string;
@@ -16,6 +17,8 @@ export interface CodexRuntimeOptions {
 }
 export declare class CodexRuntime implements AgentRuntime {
     readonly id = "codex-cli";
+    readonly providerId = "codex";
+    readonly runtimeMode = "cli";
     readonly kind = "cli";
     readonly priority = 60;
     readonly capabilities: RuntimeCapabilities;
@@ -28,7 +31,7 @@ export declare class CodexRuntime implements AgentRuntime {
     private readonly safetyMarginTokens;
     constructor(options?: CodexRuntimeOptions);
     supports(capsule: ContextCapsule): boolean;
-    health(): Promise<RuntimeHealth>;
+    health(input?: RuntimeHealthProbeRequest): Promise<RuntimeHealth>;
     runNode(capsule: ContextCapsule, signal: AbortSignal): Promise<AgentRunResult>;
     execute(task: AgentTask): Promise<AgentResult>;
     private buildPrompt;

package/dist/runtime/codex-runtime.js

@@ -9,8 +9,11 @@ import { sanitizeUserVisibleOutput } from "../util/user-visible-output.js";
 import { buildChildEnv } from "./child-env.js";
 import { contextPreflightErrorMessage, preflightProviderInput, } from "../providers/context-preflight.js";
 import { createRuntimeSandboxProfile } from "./sandbox-profile.js";
+import { staticRuntimeHealth } from "./runtime-health-probes.js";
 export class CodexRuntime {
     id = "codex-cli";
+    providerId = "codex";
+    runtimeMode = "cli";
     kind = "cli";
     priority = 60;
     capabilities = {
@@ -68,14 +71,25 @@ export class CodexRuntime {
         }
         return true;
     }
-    async health() {
-        const available = await checkCommand(this.bin).catch(() => false);
-        return {
+    async health(input = { probeKind: "static", highRisk: false }) {
+        const started = Date.now();
+        const runtimeOk = input.probeKind === "static"
+            ? await checkCommand(this.bin).catch(() => false)
+            : (await runShell(this.bin, ["--version"], { cwd: this.cwd, timeout: 5000 }).catch(() => ({ exitCode: 1 }))).exitCode === 0;
+        const available = runtimeOk;
+        return staticRuntimeHealth({
             runtimeId: this.id,
             available,
-            reason: available ? undefined : "codex CLI is not available on PATH",
-            checkedAt: new Date().toISOString(),
-        };
+            reason: available ? undefined : "codex CLI is not available or failed --version probe",
+            runtimeOk,
+            authOk: runtimeOk,
+            modelOk: true,
+            quotaOk: true,
+            rateLimitOk: true,
+            latencyMs: input.probeKind === "static" ? undefined : Date.now() - started,
+            probeKind: input.probeKind,
+            ttlMs: input.probeKind === "static" ? 60_000 : 30_000,
+        });
     }
     async runNode(capsule, signal) {
         try {
@@ -146,12 +160,7 @@ export class CodexRuntime {
                 ...(model ? { OMK_PROVIDER_MODEL: model } : {}),
             },
         });
-        const sandboxMode = task.context.sandboxMode === "read-only" || task.context.sandboxMode === "workspace-write"
-            ? task.context.sandboxMode
-            :
-                task.capabilities.write || task.capabilities.patch || task.capabilities.shell
-                    ? "workspace-write"
-                    : "read-only";
+        const sandboxMode = resolveCodexSandboxMode(task);
         const approvalPolicy = codexApprovalPolicy(task.context.approvalPolicy ?? task.context.env?.OMK_APPROVAL_POLICY, sandboxMode);
         const sandboxProfile = createRuntimeSandboxProfile({
             cwd: this.cwd,
@@ -254,10 +263,23 @@ export class CodexRuntime {
         return parts.join("\n");
     }
 }
+function resolveCodexSandboxMode(task) {
+    if (task.context.sandboxMode === "read-only" || task.context.sandboxMode === "workspace-write") {
+        return task.context.sandboxMode;
+    }
+    // Advisory API runtimes must stay read-only even if capabilities request write.
+    if (task.context.env?.OMK_PROVIDER_AUTHORITY === "advisory")
+        return "read-only";
+    if (task.capabilities.write || task.capabilities.patch || task.capabilities.shell) {
+        return "workspace-write";
+    }
+    return "read-only";
+}
 function codexApprovalPolicy(value, sandboxMode) {
     if (sandboxMode !== "read-only")
         return "on-request";
     const normalized = value?.trim().toLowerCase();
+    // OMK "ask" must never map to provider "never"; only explicit "never"/"yolo" does.
     if (normalized === "never" || normalized === "yolo")
         return "never";
     return "on-request";

package/dist/runtime/context-broker-converter.js

@@ -57,18 +57,46 @@ export async function capsuleToTask(capsule, options = {}) {
         maxLatencyMs: undefined,
     };
     const capabilities = capabilitiesFromNode(capsule);
+    const safety = safetyFromCapsule(capsule, capabilities);
+    const sovereignty = routing?.freedomd
+        ? {
+            mode: (routing.freedomd.degradedMode ?? routing.freedomd.dataBoundary) ? "freedomd" : "standard",
+            dataBoundary: routing.freedomd.dataBoundary ?? "internal",
+            retentionDecision: "allow",
+            jurisdictionDecision: "allow",
+            providerCutoffRisk: 0,
+            localFallbackAvailable: false,
+            reason: routing.freedomd.sovereigntyReason ?? "from dag routing",
+        }
+        : undefined;
     const task = {
         prompt: capsule.task,
         context,
         tools,
         providerPolicy,
         capabilities,
+        safety,
+        sovereignty,
     };
     return task;
 }
 function isAbortSignal(value) {
     return "aborted" in value && typeof value.addEventListener === "function";
 }
+function safetyFromCapsule(capsule, capabilities) {
+    const routing = capsule.node.routing;
+    const risk = routing?.risk ?? (capabilities.shell || capabilities.merge ? "shell" : capabilities.write || capabilities.patch ? "write" : "read");
+    const authorityMode = routing?.assignedProviderAuthority
+        ?? (routing?.readOnly === true ? "advisory" : "authority");
+    return {
+        risk,
+        riskTrace: routing?.riskTrace,
+        approvalPolicy: routing?.approvalPolicy ?? routing?.executionPrompt ?? "interactive",
+        sandboxMode: routing?.sandboxMode ?? (routing?.readOnly === true ? "read-only" : "workspace-write"),
+        evidenceRequired: routing?.evidenceRequired === true || capabilities.write || capabilities.patch || capabilities.shell || capabilities.merge,
+        authorityMode,
+    };
+}
 function capabilitiesFromNode(capsule) {
     const node = capsule.node;
     const routing = node.routing;
@@ -77,7 +105,9 @@ function capabilitiesFromNode(capsule) {
     const assigned = new Set(routing?.assignedProviderCapabilities ?? []);
     const merge = assigned.has("merge") || role === "merger" || role === "integrator" || role === "orchestrator";
     const write = assigned.has("write") || merge || role === "coder" || role === "executor" || role === "refactorer";
-    const shell = assigned.has("shell") || routing?.requiresToolCalling === true || gates.includes("command-pass") || gates.includes("test-pass");
+    const shell = routing?.readOnly === true
+        ? false
+        : assigned.has("shell") || routing?.requiresToolCalling === true || gates.includes("command-pass") || gates.includes("test-pass");
     const review = assigned.has("review") || role === "reviewer" || role === "qa" || role === "tester" || gates.includes("review-pass");
     const mcp = assigned.has("mcp") || routing?.requiresMcp === true;
     const vision = assigned.has("vision");
@@ -88,7 +118,7 @@ function capabilitiesFromNode(capsule) {
         mcp,
         patch: routing?.readOnly === true ? false : write,
         review,
-        merge,
+        merge: routing?.readOnly === true ? false : merge,
         vision,
         toolCalling: routing?.requiresToolCalling === true || assigned.has("toolCalling"),
         maxTokens: capsule.budget.maxInputTokens,

package/dist/runtime/context-broker.js

@@ -5,11 +5,27 @@ import { mkdir, readFile, stat, writeFile } from "fs/promises";
 import { createContextBudgetOptimizer } from "./context-budget-optimizer.js";
 import { createDecisionTraceStore } from "../evidence/decision-trace.js";
 import { evaluateHeadroom } from "./headroom-policy.js";
+import { getRunArtifactPath } from "../util/run-store.js";
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 function resolveBudget(node) {
     const preset = node.routing?.contextBudget ?? "small";
     return CONTEXT_BUDGET_PRESETS[preset] ?? DEFAULT_CONTEXT_BUDGET;
 }
+async function loadPrivatePromptPayload(node, runId, projectRoot) {
+    const ref = node.routing?.promptPayloadRef;
+    if (!ref || !runId)
+        return undefined;
+    try {
+        const raw = await readFile(getRunArtifactPath(runId, ref, projectRoot), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.compiledPrompt !== "string" || parsed.compiledPrompt.trim().length === 0)
+            return undefined;
+        return parsed.compiledPrompt;
+    }
+    catch {
+        return undefined;
+    }
+}
 function collectDependencySummaries(node, state) {
     if (!state || !node.dependsOn.length)
         return [];
@@ -238,9 +254,11 @@ export function createContextBroker(options = {}) {
             nodeId: node.id,
             graphMemory,
         }).catch(() => { });
+        const privatePrompt = await loadPrivatePromptPayload(node, state?.runId, projectRoot);
         const task = [
             `Execute DAG node: ${node.id}`,
             `Name: ${node.name}`,
+            privatePrompt ? `PrivatePrompt: ${privatePrompt}` : undefined,
             `Role: ${node.role}`,
             node.routing?.actionAtom ? `ActionAtom: ${node.routing.actionAtom.id} | ${node.routing.actionAtom.label} | ${node.routing.actionAtom.verb} ${node.routing.actionAtom.object ?? "assigned scope"} | evidence=${node.routing.actionAtom.evidenceTarget} | done=${node.routing.actionAtom.doneCondition}` : undefined,
             node.routing?.skills?.length ? `Skills: ${node.routing.skills.join(", ")}` : undefined,

package/dist/runtime/contracts/evidence.d.ts

@@ -68,6 +68,58 @@ export interface AdapterTestResult {
     readonly score: number;
     readonly details?: string;
 }
+/** Kinds of output gates that can satisfy evidence-required turns. */
+export type EvidenceGateKind = "file-exists" | "test-pass" | "review-pass" | "command-pass" | "summary" | "artifact" | "diff";
+/** A declared gate requirement. Declarations are not evidence. */
+export interface EvidenceRequirement {
+    readonly gate: EvidenceGateKind;
+    readonly ref?: string;
+    readonly required: boolean;
+}
+/** A produced, replayable evidence observation. */
+export interface EvidenceObservation {
+    readonly kind: EvidenceGateKind;
+    readonly source: "stdout" | "metadata" | "artifact" | "file";
+    readonly ref?: string;
+    readonly artifactPath?: string;
+    readonly timestamp: string;
+    readonly replayable: boolean;
+    readonly redacted: boolean;
+    /** Confidence that this observation is replayable, command-backed evidence. */
+    readonly confidence: number;
+}
+/** Result of checking whether a node/task produced required evidence. */
+export interface EvidenceGateCheck {
+    readonly required: boolean;
+    readonly satisfied: boolean;
+    readonly gates: readonly EvidenceGateKind[];
+    readonly missing: readonly EvidenceGateKind[];
+    readonly reason: string;
+    readonly requirements?: readonly EvidenceRequirement[];
+    readonly observations?: readonly EvidenceObservation[];
+}
+export declare function isEvidenceGateKind(value: string | undefined): value is EvidenceGateKind;
+export declare function evidenceRequirementsFromOutputs(outputs: readonly {
+    gate?: string;
+    ref?: string;
+    required?: boolean;
+}[] | undefined): EvidenceRequirement[];
+export declare function hasDeclaredEvidenceRequirement(outputs: readonly {
+    gate?: string;
+    ref?: string;
+    required?: boolean;
+}[] | undefined): boolean;
+export declare function evidenceObservationsFromResult(input: {
+    readonly metadata?: Record<string, unknown> | null;
+    readonly stdout?: string;
+    readonly artifactPaths?: readonly string[];
+    readonly timestamp?: string;
+}): EvidenceObservation[];
+export declare function checkEvidenceGate(required: boolean | undefined, outputs: readonly {
+    gate?: string;
+    ref?: string;
+    required?: boolean;
+}[] | undefined, metadata?: Record<string, unknown> | null, stdout?: string, artifactPaths?: readonly string[]): EvidenceGateCheck;
 /** Per-gate check result. */
 export interface GateCheck {
     readonly gate: string;

package/dist/runtime/contracts/evidence.js

@@ -4,4 +4,131 @@
  * Core interfaces that bridge reasoning traces, runtime decisions,
  * provider maturity, and release gates into a verifiable evidence model.
  */
-export {};
+const EVIDENCE_GATE_KINDS = [
+    "file-exists",
+    "test-pass",
+    "review-pass",
+    "command-pass",
+    "summary",
+    "artifact",
+    "diff",
+];
+export function isEvidenceGateKind(value) {
+    return Boolean(value && EVIDENCE_GATE_KINDS.includes(value.toLowerCase()));
+}
+export function evidenceRequirementsFromOutputs(outputs) {
+    const requirements = [];
+    for (const output of outputs ?? []) {
+        const kind = output.gate?.toLowerCase();
+        if (!isEvidenceGateKind(kind))
+            continue;
+        if (output.required === false)
+            continue;
+        requirements.push({ gate: kind, ref: output.ref, required: true });
+    }
+    return requirements;
+}
+export function hasDeclaredEvidenceRequirement(outputs) {
+    return evidenceRequirementsFromOutputs(outputs).length > 0;
+}
+export function evidenceObservationsFromResult(input) {
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const observations = [];
+    const metadata = input.metadata ?? undefined;
+    const metaGates = metadata?.evidenceGates;
+    if (Array.isArray(metaGates)) {
+        for (const raw of metaGates) {
+            const gate = typeof raw === "string" ? raw.toLowerCase() : undefined;
+            if (isEvidenceGateKind(gate)) {
+                observations.push({ kind: gate, source: "metadata", timestamp, replayable: true, redacted: true, confidence: 0.9 });
+            }
+        }
+    }
+    if (metadata?.commandPass === true || metadata?.testPass === true || metadata?.buildPass === true) {
+        observations.push({ kind: "command-pass", source: "metadata", timestamp, replayable: true, redacted: true, confidence: 0.9 });
+    }
+    if (metadata?.diff || metadata?.patch || metadata?.changedFiles) {
+        observations.push({ kind: "diff", source: "metadata", timestamp, replayable: true, redacted: true, confidence: 0.9 });
+    }
+    const artifactRef = metadata?.artifact ?? metadata?.artifactPath ?? metadata?.evidenceRef;
+    if (typeof artifactRef === "string" && artifactRef.trim().length > 0) {
+        observations.push({ kind: "artifact", source: "metadata", ref: artifactRef, artifactPath: artifactRef, timestamp, replayable: true, redacted: true, confidence: 0.95 });
+    }
+    for (const artifactPath of input.artifactPaths ?? []) {
+        observations.push({ kind: "artifact", source: "artifact", artifactPath, ref: artifactPath, timestamp, replayable: true, redacted: true, confidence: 0.95 });
+    }
+    const stdout = input.stdout ?? "";
+    if (stdout.trim().length > 0) {
+        observations.push({ kind: "summary", source: "stdout", timestamp, replayable: true, redacted: true, confidence: 0.4 });
+    }
+    if (/\b(pass(ed)?|success|ok)\b/i.test(stdout) && /\b(test|check|build|lint|command)\b/i.test(stdout)) {
+        observations.push({ kind: "command-pass", source: "stdout", timestamp, replayable: true, redacted: true, confidence: 0.4 });
+    }
+    return observations;
+}
+function minimumConfidenceFor(requirement) {
+    if (requirement.gate === "command-pass" || requirement.gate === "test-pass")
+        return 0.8;
+    return 0;
+}
+function observationSatisfies(requirement, observation) {
+    if (!observation.replayable || !observation.redacted)
+        return false;
+    if (observation.confidence < minimumConfidenceFor(requirement))
+        return false;
+    if (observation.kind === requirement.gate)
+        return true;
+    if (requirement.gate === "test-pass" && observation.kind === "command-pass")
+        return true;
+    if (requirement.gate === "file-exists" && observation.kind === "artifact")
+        return true;
+    return false;
+}
+export function checkEvidenceGate(required, outputs, metadata, stdout, artifactPaths) {
+    const requirements = evidenceRequirementsFromOutputs(outputs);
+    const observations = evidenceObservationsFromResult({ metadata, stdout, artifactPaths });
+    const observedKinds = new Set(observations.map((o) => o.kind));
+    if (!required) {
+        return { required: false, satisfied: true, gates: [...observedKinds], missing: [], reason: "evidence not required", requirements, observations };
+    }
+    if (requirements.length === 0 && observations.length > 0) {
+        const strongObservations = observations.filter((observation) => observation.confidence >= 0.8 && observation.replayable && observation.redacted);
+        if (strongObservations.length > 0) {
+            return {
+                required: true,
+                satisfied: true,
+                gates: [...new Set(strongObservations.map((observation) => observation.kind))],
+                missing: [],
+                reason: `evidence satisfied by high-confidence observations without explicit gate: ${[...new Set(strongObservations.map((observation) => observation.kind))].join(", ")}`,
+                requirements,
+                observations,
+            };
+        }
+    }
+    const effectiveRequirements = requirements.length > 0
+        ? requirements
+        : EVIDENCE_GATE_KINDS.map((gate) => ({ gate, required: true }));
+    const missing = effectiveRequirements
+        .filter((requirement) => !observations.some((observation) => observationSatisfies(requirement, observation)))
+        .map((requirement) => requirement.gate);
+    if (missing.length === 0) {
+        return {
+            required: true,
+            satisfied: true,
+            gates: [...observedKinds],
+            missing: [],
+            reason: `evidence satisfied by observations: ${[...observedKinds].join(", ") || "none"}`,
+            requirements: effectiveRequirements,
+            observations,
+        };
+    }
+    return {
+        required: true,
+        satisfied: false,
+        gates: [...observedKinds],
+        missing,
+        reason: `required evidence observations missing: ${[...new Set(missing)].join(", ")}`,
+        requirements: effectiveRequirements,
+        observations,
+    };
+}

package/dist/runtime/contracts/shared.d.ts

@@ -26,9 +26,36 @@ export interface RuntimeCapabilities {
     supportsStructuredOutput?: boolean;
     supportsToolCalling?: boolean;
 }
+export type HealthState = "pass" | "fail" | "unknown";
+export type RuntimeHealthProbeKind = "none" | "static" | "cheap-call" | "live-call";
+export interface RuntimeHealthVector {
+    /** Legacy boolean dimensions retained for backward compatibility. */
+    runtimeOk?: boolean;
+    authOk?: boolean;
+    modelOk?: boolean;
+    quotaOk?: boolean;
+    rateLimitOk?: boolean;
+    /** Tri-state dimensions used by health-aware routing v2. */
+    runtime?: HealthState;
+    auth?: HealthState;
+    model?: HealthState;
+    quota?: HealthState;
+    rateLimit?: HealthState;
+    latencyMs?: number;
+    lastProbeKind?: RuntimeHealthProbeKind;
+    checkedAt?: string;
+    expiresAt?: string;
+}
+export interface RuntimeHealthProbeRequest {
+    readonly probeKind: RuntimeHealthProbeKind;
+    readonly taskRisk?: string;
+    readonly highRisk: boolean;
+}
 export interface RuntimeHealth {
     runtimeId: RuntimeId;
     available: boolean;
     reason?: string;
     checkedAt: string;
+    /** Structured health signals beyond a binary available flag. */
+    vector?: RuntimeHealthVector;
 }

package/dist/runtime/data-retention-gate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Freedomd data-retention gate.
+ *
+ * Decides whether a task's prompt, attachments, and relevant files may be sent
+ * to a provider given its retention profile and the org/user policy. The gate
+ * returns one of {allow, redact, downgrade, block} and never leaks secret-like
+ * spans to a retained provider.
+ */
+import type { AgentRuntime, AgentTask } from "./agent-runtime.js";
+import type { ProviderSovereigntyProfile } from "./provider-sovereignty.js";
+export type DataBoundary = "public" | "internal" | "customer" | "secret";
+export type RetentionDecision = "allow" | "redact" | "downgrade" | "block";
+export interface DataSensitivity {
+    readonly boundary: DataBoundary;
+    readonly containsSecret: boolean;
+    readonly containsCustomerData: boolean;
+    readonly sensitiveSpans: readonly string[];
+}
+export interface ProviderRetentionProfile {
+    readonly retentionDays: number;
+    readonly zeroDataRetention: boolean;
+    readonly trainingUse: boolean;
+    readonly auditAccessUnknown: boolean;
+}
+export interface DataRetentionGateInput {
+    readonly task: AgentTask;
+    readonly runtime: AgentRuntime;
+    readonly providerProfile: ProviderSovereigntyProfile;
+    readonly orgMaxRetentionDays: number;
+    readonly allowRedaction: boolean;
+    readonly relevantFiles?: readonly string[];
+}
+export interface DataRetentionGateResult {
+    readonly decision: RetentionDecision;
+    readonly reason: string;
+    readonly sensitivity: DataSensitivity;
+    readonly redactedSpans?: readonly string[];
+    readonly downgradeMode?: "local-only-or-zdr-provider" | "read-only-local-review";
+}
+export declare function classifyDataSensitivity(task: AgentTask, relevantFiles?: readonly string[]): DataSensitivity;
+export declare function providerRetentionProfileFromSovereignty(profile: ProviderSovereigntyProfile): ProviderRetentionProfile;
+export declare function evaluateDataRetentionGate(input: DataRetentionGateInput): DataRetentionGateResult;

package/dist/runtime/data-retention-gate.js

@@ -0,0 +1,123 @@
+/**
+ * Freedomd data-retention gate.
+ *
+ * Decides whether a task's prompt, attachments, and relevant files may be sent
+ * to a provider given its retention profile and the org/user policy. The gate
+ * returns one of {allow, redact, downgrade, block} and never leaks secret-like
+ * spans to a retained provider.
+ */
+import { maskSensitiveText } from "../util/secret-mask.js";
+import { runtimeProviderId, runtimeModeOf } from "./authority-matrix.js";
+const SECRET_KEYWORDS = [
+    "password", "secret", "token", "api_key", "apikey", "private_key",
+    "credential", "bearer", "authorization", "session", "cookie",
+];
+const CUSTOMER_DATA_KEYWORDS = [
+    "customer", "user_id", "email", "phone", "ssn", "personal",
+    "gdpr", "hipaa", "pci", "pii",
+];
+function boundaryForRisk(risk) {
+    if (risk === "shell" || risk === "merge")
+        return "secret";
+    if (risk === "write" || risk === "patch")
+        return "internal";
+    return "public";
+}
+function classifyTextSensitivity(text) {
+    const lower = text.toLowerCase();
+    const sensitiveSpans = [];
+    let containsSecret = false;
+    let containsCustomerData = false;
+    for (const keyword of SECRET_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            containsSecret = true;
+            sensitiveSpans.push(`keyword:${keyword}`);
+        }
+    }
+    for (const keyword of CUSTOMER_DATA_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            containsCustomerData = true;
+            sensitiveSpans.push(`keyword:${keyword}`);
+        }
+    }
+    const masked = maskSensitiveText(text);
+    if (masked !== text) {
+        containsSecret = true;
+        sensitiveSpans.push("pattern:secret-like");
+    }
+    return { containsSecret, containsCustomerData, sensitiveSpans: [...new Set(sensitiveSpans)] };
+}
+export function classifyDataSensitivity(task, relevantFiles) {
+    const text = [
+        task.prompt,
+        task.context.goal ?? "",
+        task.context.system ?? "",
+        ...(task.attachments ?? []).map((a) => a.name),
+        ...(relevantFiles ?? []),
+    ].join("\n");
+    const classified = classifyTextSensitivity(text);
+    const boundary = boundaryForRisk(task.safety?.risk);
+    return {
+        boundary,
+        containsSecret: classified.containsSecret,
+        containsCustomerData: classified.containsCustomerData,
+        sensitiveSpans: classified.sensitiveSpans,
+    };
+}
+export function providerRetentionProfileFromSovereignty(profile) {
+    return {
+        retentionDays: profile.retentionDays,
+        zeroDataRetention: profile.zeroDataRetention,
+        trainingUse: profile.trainingUse,
+        auditAccessUnknown: !profile.zeroDataRetention && profile.retentionDays > 0,
+    };
+}
+export function evaluateDataRetentionGate(input) {
+    const { task, runtime, providerProfile, orgMaxRetentionDays, allowRedaction } = input;
+    const sensitivity = classifyDataSensitivity(task, input.relevantFiles);
+    if (sensitivity.containsSecret) {
+        return {
+            decision: "block",
+            reason: "secret-like data cannot be sent to retained provider",
+            sensitivity,
+        };
+    }
+    const retention = providerRetentionProfileFromSovereignty(providerProfile);
+    if (sensitivity.containsCustomerData && !retention.zeroDataRetention) {
+        if (allowRedaction) {
+            return {
+                decision: "redact",
+                reason: `customer data redacted before sending to ${runtimeProviderId(runtime)}:${runtimeModeOf(runtime)}`,
+                sensitivity,
+                redactedSpans: sensitivity.sensitiveSpans,
+            };
+        }
+        return {
+            decision: "downgrade",
+            reason: "customer data with non-zero retention provider; downgrade required",
+            sensitivity,
+            downgradeMode: "local-only-or-zdr-provider",
+        };
+    }
+    if (retention.retentionDays > orgMaxRetentionDays) {
+        return {
+            decision: "block",
+            reason: `provider retention ${retention.retentionDays}d exceeds policy ${orgMaxRetentionDays}d`,
+            sensitivity,
+        };
+    }
+    const risk = task.safety?.risk;
+    if ((risk === "write" || risk === "shell" || risk === "merge") && retention.auditAccessUnknown) {
+        return {
+            decision: "downgrade",
+            reason: "high-risk task with unclear retention/audit boundary",
+            sensitivity,
+            downgradeMode: "read-only-local-review",
+        };
+    }
+    return {
+        decision: "allow",
+        reason: "retention policy acceptable for data boundary",
+        sensitivity,
+    };
+}

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

@@ -5,6 +5,7 @@
  * Supports SSE streaming, tool calling, and reasoning_content.
  */
 import type { AgentRuntime, AgentRunResult, AgentResult, AgentTask, RuntimeCapabilities, RuntimeHealth } from "./agent-runtime.js";
+import type { RuntimeHealthProbeRequest } from "./contracts/shared.js";
 import type { ContextCapsule } from "./context-capsule.js";
 export interface DeepSeekRuntimeOptions {
     apiKey?: string;
@@ -13,6 +14,9 @@ export interface DeepSeekRuntimeOptions {
 }
 export declare class DeepSeekRuntime implements AgentRuntime {
     readonly id = "deepseek-api";
+    readonly providerId = "deepseek";
+    readonly advisory = true;
+    readonly runtimeMode = "api";
     readonly kind = "api";
     readonly priority = 40;
     readonly capabilities: RuntimeCapabilities;
@@ -21,7 +25,7 @@ export declare class DeepSeekRuntime implements AgentRuntime {
     private readonly baseUrl;
     constructor(options?: DeepSeekRuntimeOptions);
     supports(capsule: ContextCapsule): boolean;
-    health(): Promise<RuntimeHealth>;
+    health(input?: RuntimeHealthProbeRequest): Promise<RuntimeHealth>;
     runNode(capsule: ContextCapsule, signal: AbortSignal): Promise<AgentRunResult>;
     execute(task: AgentTask): Promise<AgentResult>;
     private parseStreamResponse;