@iislee/opencodex 2.11.0 → 2.35.0

package/src/lab/automation/cooldown.ts

@@ -0,0 +1,103 @@
+import { LAB_AUTOMATION_HARD_MAX } from "./constants";
+import type { LabAutomationPolicyV1, LabAutomationStateV1 } from "./types";
+
+/**
+ * A persisted, expiring tombstone used only when the bounded per-key cooldown map
+ * cannot accept another key. While active, scheduled planning fails closed for all
+ * run keys. Its expiry covers every cooldown that was collapsed into it.
+ */
+const COOLDOWN_SATURATION_KEY = "__ocx_cooldown_saturation__";
+
+function saturationActive(cooldowns: Record<string, number>, now: number): boolean {
+  const until = cooldowns[COOLDOWN_SATURATION_KEY];
+  return typeof until === "number" && until > now;
+}
+
+export function cooldownActive(state: LabAutomationStateV1, key: string, now: number): boolean {
+  const cooldowns = activeCooldowns(state, now);
+  if (saturationActive(cooldowns, now)) return true;
+  const until = cooldowns[key];
+  return typeof until === "number" && until > now;
+}
+
+function activeCooldowns(state: LabAutomationStateV1, now: number): Record<string, number> {
+  const next: Record<string, number> = {};
+  for (const [key, until] of Object.entries(state.cooldownUntilByKey)) {
+    if (until > now) next[key] = until;
+  }
+  return next;
+}
+
+function reservedCooldownKeys(state: LabAutomationStateV1, now: number): Set<string> {
+  const reserved = new Set(Object.keys(activeCooldowns(state, now)));
+  for (const run of state.runs) {
+    if (run.trigger === "scheduled" && run.state === "running") reserved.add(run.runKey);
+  }
+  return reserved;
+}
+
+/** True when another scheduled run could no longer reserve a durable failure cooldown. */
+export function cooldownCapacityExhausted(state: LabAutomationStateV1, now: number): boolean {
+  const cooldowns = activeCooldowns(state, now);
+  if (saturationActive(cooldowns, now)) return true;
+  return reservedCooldownKeys({ ...state, cooldownUntilByKey: cooldowns }, now).size
+    >= LAB_AUTOMATION_HARD_MAX.maxPersistedRuns;
+}
+
+/** Reserve capacity implicitly through the running scheduled record before dispatch. */
+export function canReserveScheduledCooldown(
+  state: LabAutomationStateV1,
+  runKey: string,
+  now: number,
+): boolean {
+  const cooldowns = activeCooldowns(state, now);
+  if (saturationActive(cooldowns, now)) return false;
+  const reserved = reservedCooldownKeys({ ...state, cooldownUntilByKey: cooldowns }, now);
+  return reserved.has(runKey) || reserved.size < LAB_AUTOMATION_HARD_MAX.maxPersistedRuns;
+}
+
+export function setCooldown(
+  state: LabAutomationStateV1,
+  key: string,
+  untilMs: number,
+  now: number,
+): LabAutomationStateV1 {
+  const next = activeCooldowns(state, now);
+  const saturationUntil = next[COOLDOWN_SATURATION_KEY];
+  if (typeof saturationUntil === "number") {
+    next[COOLDOWN_SATURATION_KEY] = Math.max(saturationUntil, untilMs);
+    return { ...state, cooldownUntilByKey: next };
+  }
+  if (!(key in next) && Object.keys(next).length >= LAB_AUTOMATION_HARD_MAX.maxPersistedRuns) {
+    const longestExistingUntil = Math.max(now, ...Object.values(next));
+    return {
+      ...state,
+      cooldownUntilByKey: {
+        [COOLDOWN_SATURATION_KEY]: Math.max(longestExistingUntil, untilMs),
+      },
+    };
+  }
+  next[key] = untilMs;
+  return { ...state, cooldownUntilByKey: next };
+}
+
+export function clearCooldown(state: LabAutomationStateV1, key: string): LabAutomationStateV1 {
+  if (!state.cooldownUntilByKey[key]) return state;
+  const next = { ...state.cooldownUntilByKey };
+  delete next[key];
+  return { ...state, cooldownUntilByKey: next };
+}
+
+export function cooldownForFailure(
+  policy: LabAutomationPolicyV1,
+  classification: string,
+  now: number,
+): number {
+  if (classification === "authentication_blocked" || classification === "auth_blocked" || classification === "quota_blocked" || classification === "region_blocked") {
+    return now + policy.blockedCooldownMs;
+  }
+  if (classification === "harness_failure") {
+    return now + policy.blockedCooldownMs;
+  }
+  return now + policy.failureCooldownMs;
+}

package/src/lab/automation/dispatch.ts

@@ -0,0 +1,211 @@
+import { subjectIdForSubject, scenarioManifestDigest } from "../digest";
+import { expandScenario, loadCaseAuthority } from "../conformance/manifest";
+import { resolveProtocolExecutionContext, runScenario } from "../conformance/executor";
+import { buildProtocolSubjectV1 } from "../subject/protocol-subject";
+import { suiteManifestDigestForCase } from "../conformance/suite-manifest";
+import { persistConformanceResult } from "../observe/from-conformance";
+import { expandLiveScenario, loadLiveCaseAuthority } from "../live/manifest";
+import { runLiveScenario } from "../live/executor";
+import { liveSuiteManifestDigestForCase } from "../live/suite-manifest";
+import { persistLiveResult } from "../observe/from-live";
+import { rebuildLabProjection } from "../projection/rebuild";
+import { resolvePolicyCompatibilitySubjects } from "../../routing/compatibility/subject";
+import type { AutomationDispatchDeps, LabAutomationRunRecordV1 } from "./types";
+import { LabAutomationError } from "./types";
+import { buildAutomationLiveRouteContext } from "./route-context";
+import {
+  buildLabAutomationRunKey,
+  liveExecutionContractDigest,
+  protocolExecutionContractDigest,
+} from "./run-key";
+
+export interface DispatchResult {
+  terminalState: "completed" | "blocked" | "failed";
+  terminalCode: string;
+  cooldownCode: string;
+  liveRequest: boolean;
+}
+
+interface ExpectedRunIdentity {
+  runKey: string;
+  subjectId: string;
+  suiteId: string;
+  suiteVersion: string;
+  suiteManifestDigest: string;
+  scenarioId: string;
+  scenarioVersion: string;
+  scenarioManifestDigest: string;
+}
+
+function runIdentityMatches(run: LabAutomationRunRecordV1, expected: ExpectedRunIdentity): boolean {
+  return run.runKey === expected.runKey
+    && run.subjectId === expected.subjectId
+    && run.suiteId === expected.suiteId
+    && run.suiteVersion === expected.suiteVersion
+    && run.suiteManifestDigest === expected.suiteManifestDigest
+    && run.scenarioId === expected.scenarioId
+    && run.scenarioVersion === expected.scenarioVersion
+    && run.scenarioManifestDigest === expected.scenarioManifestDigest;
+}
+
+function shouldEnforceRunIdentity(run: LabAutomationRunRecordV1, deps: AutomationDispatchDeps): boolean {
+  // Production orchestration always sets the explicit guard. Canonical planned run keys also
+  // self-identify here so direct internal callers cannot accidentally bypass revalidation.
+  return deps.enforceRunIdentity === true || /^[0-9a-f]{64}$/i.test(run.runKey);
+}
+
+function contractChanged(): DispatchResult {
+  return {
+    terminalState: "blocked",
+    terminalCode: "run_contract_changed",
+    cooldownCode: "run_contract_changed",
+    liveRequest: false,
+  };
+}
+
+function routeIneligible(): DispatchResult {
+  return {
+    terminalState: "blocked",
+    terminalCode: "route_ineligible",
+    cooldownCode: "route_ineligible",
+    liveRequest: false,
+  };
+}
+
+function assertNotCancelled(signal?: AbortSignal): void {
+  if (signal?.aborted) throw new LabAutomationError("cancelled", "cancelled");
+}
+
+/** Closed dispatcher to existing CL-01 / CL-03 / CL-07 producers. */
+export async function dispatchLabAutomationRun(
+  run: LabAutomationRunRecordV1,
+  deps: AutomationDispatchDeps,
+): Promise<DispatchResult> {
+  const configDir = deps.configDir;
+  switch (run.evidenceLayer) {
+    case "protocol_conformance": {
+      assertNotCancelled(deps.abortSignal);
+      const authority = loadCaseAuthority();
+      const caseRecord = authority.cases.find((row) => row.id === run.scenarioId);
+      if (!caseRecord) {
+        throw new LabAutomationError("missing protocol scenario", "dispatch_failure");
+      }
+      const executionContext = resolveProtocolExecutionContext(caseRecord);
+      const subject = buildProtocolSubjectV1(executionContext);
+      const subjectId = subjectIdForSubject(subject);
+      const scenarioDigest = scenarioManifestDigest(expandScenario(caseRecord, authority));
+      const suiteDigest = suiteManifestDigestForCase(caseRecord, authority);
+      const suiteVersion = authority.manifestDefaults.suiteVersion;
+      const scenarioVersion = authority.manifestDefaults.version;
+      const expected: ExpectedRunIdentity = {
+        runKey: buildLabAutomationRunKey({
+          evidenceLayer: "protocol_conformance",
+          subjectId,
+          suiteId: caseRecord.suite,
+          suiteVersion,
+          suiteManifestDigest: suiteDigest,
+          scenarioId: caseRecord.id,
+          scenarioVersion,
+          scenarioManifestDigest: scenarioDigest,
+          executionContractDigest: protocolExecutionContractDigest(),
+        }),
+        subjectId,
+        suiteId: caseRecord.suite,
+        suiteVersion,
+        suiteManifestDigest: suiteDigest,
+        scenarioId: caseRecord.id,
+        scenarioVersion,
+        scenarioManifestDigest: scenarioDigest,
+      };
+      if (shouldEnforceRunIdentity(run, deps) && !runIdentityMatches(run, expected)) return contractChanged();
+      const result = await runScenario(caseRecord);
+      assertNotCancelled(deps.abortSignal);
+      persistConformanceResult(result, caseRecord, authority, { configDir });
+      rebuildLabProjection(configDir);
+      return {
+        terminalState: result.passed ? "completed" : "failed",
+        terminalCode: result.passed ? "pass" : "protocol_fail",
+        cooldownCode: result.passed ? "pass" : "protocol_failure",
+        liveRequest: false,
+      };
+    }
+    case "live_route_compatibility": {
+      assertNotCancelled(deps.abortSignal);
+      if (!deps.routeExecutor) return routeIneligible();
+      if (!deps.loadConfig || !run.providerName || !run.modelId) {
+        throw new LabAutomationError("live dispatch requires route configuration", "dispatch_failure");
+      }
+      const config = deps.loadConfig();
+      const routed = config.providers?.[run.providerName];
+      if (!routed) return routeIneligible();
+      const resolved = resolvePolicyCompatibilitySubjects(
+        config,
+        run.providerName,
+        run.modelId,
+        routed,
+        configDir,
+      );
+      if (!resolved.route) return routeIneligible();
+      const authority = loadLiveCaseAuthority();
+      const caseRecord = authority.cases.find((row) => row.id === run.scenarioId);
+      if (!caseRecord) {
+        throw new LabAutomationError("missing live scenario", "dispatch_failure");
+      }
+      const scenarioDigest = scenarioManifestDigest(expandLiveScenario(caseRecord, authority));
+      const suiteDigest = liveSuiteManifestDigestForCase(caseRecord, authority);
+      const suiteVersion = authority.manifestDefaults.suiteVersion;
+      const scenarioVersion = authority.manifestDefaults.version;
+      const subjectId = resolved.route.subjectId;
+      const expected: ExpectedRunIdentity = {
+        runKey: buildLabAutomationRunKey({
+          evidenceLayer: "live_route_compatibility",
+          subjectId,
+          suiteId: caseRecord.suite,
+          suiteVersion,
+          suiteManifestDigest: suiteDigest,
+          scenarioId: caseRecord.id,
+          scenarioVersion,
+          scenarioManifestDigest: scenarioDigest,
+          executionContractDigest: liveExecutionContractDigest(),
+        }),
+        subjectId,
+        suiteId: caseRecord.suite,
+        suiteVersion,
+        suiteManifestDigest: suiteDigest,
+        scenarioId: caseRecord.id,
+        scenarioVersion,
+        scenarioManifestDigest: scenarioDigest,
+      };
+      if (shouldEnforceRunIdentity(run, deps) && !runIdentityMatches(run, expected)) return contractChanged();
+      const routeContext = buildAutomationLiveRouteContext(
+        resolved.route,
+        routed.allowPrivateNetwork === true,
+      );
+      const result = await runLiveScenario(caseRecord, routeContext, {
+        configDir,
+        routeExecutor: deps.routeExecutor,
+        cancelSignal: deps.abortSignal,
+        resolve: deps.resolve,
+      });
+      // Cancellation is orchestration state. Never mint canonical evidence after an abort.
+      assertNotCancelled(deps.abortSignal);
+      if (result.executionAuthority === "trusted_route") {
+        persistLiveResult(result, caseRecord, authority, { configDir });
+        rebuildLabProjection(configDir);
+      }
+      const blocked = result.classification === "authentication_blocked"
+        || result.classification === "quota_blocked"
+        || result.classification === "region_blocked";
+      return {
+        terminalState: result.passed ? "completed" : blocked ? "blocked" : "failed",
+        terminalCode: result.secondaryCode ?? result.classification,
+        cooldownCode: result.classification,
+        liveRequest: true,
+      };
+    }
+    case "task_effectiveness":
+      throw new LabAutomationError("task_effectiveness background execution is not enabled", "task_background_disabled");
+    default:
+      throw new LabAutomationError(`unsupported evidence layer ${run.evidenceLayer as string}`, "dispatch_failure");
+  }
+}

package/src/lab/automation/index.ts

@@ -0,0 +1,13 @@
+export * from "./types";
+export * from "./constants";
+export * from "./policy";
+export * from "./run-key";
+export * from "./persistence";
+export * from "./planner";
+export * from "./queue";
+export * from "./budgets";
+export * from "./cooldown";
+export * from "./dispatch";
+export * from "./recovery";
+export * from "./runs-query";
+export * from "./orchestrator";