@bitkyc08/opencodex 2.12.0 → 2.13.0

package/src/images/loop.ts

@@ -907,7 +907,7 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
     }, 2_000,
     {
       translatorBudget,
-      replayCacheScope: parsed._clientThreadId ?? "global",
+      replayCacheScope: parsed._reasoningReplayScope,
       ...(deps.forceEmptyResponseId ? { responseId: "" } : {}),
       hideThinkingSummary: parsed.options.hideThinkingSummary,
       stallTimeoutSec: deps.stallTimeoutSec,

package/src/lab/artifacts/sanitize.ts

@@ -8,8 +8,8 @@ import { jcsStringify } from "../digest";
 import { redactSecretString } from "../../lib/redact";
 
 const FORBIDDEN_KEY = /^(?:authorization|proxy-authorization|cookie|set-cookie|api[-_]?key|x-api-key|token|secret|password|email|prompt|messages|content|body|url|hostname|baseUrl|path|account|alias)$/i;
-const SECRETISH = /sk-[a-z0-9]{10,}|Bearer\s+[A-Za-z0-9._\-]+|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}/i;
-const SECRETISH_GLOBAL = /sk-[a-z0-9]{10,}|Bearer\s+[A-Za-z0-9._\-]+|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}/gi;
+const SECRETISH = /sk-[a-z0-9]{10,}|credential-canary-[a-z0-9]{10,}|Bearer\s+[A-Za-z0-9._\-]+|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}/i;
+const SECRETISH_GLOBAL = new RegExp(SECRETISH.source, "gi");
 
 export function redactForArtifact(artifactClass: ArtifactClass, payload: unknown): unknown {
   if (
@@ -583,4 +583,4 @@ export function sanitizeDiagnostic(value: unknown): string {
 
 export function sanitizedJsonBytes(value: unknown): Uint8Array {
   return new TextEncoder().encode(jcsStringify(scrubValue(value, 0)));
-}
+}

package/src/lab/automation/budgets.ts

@@ -0,0 +1,78 @@
+import { LAB_AUTOMATION_HARD_MAX } from "./constants";
+import type { LabAutomationPolicyV1, LabAutomationStateV1 } from "./types";
+
+export function rollBudgetWindow(state: LabAutomationStateV1, now: number): LabAutomationStateV1 {
+  if (now - state.budgetWindowStartedAt < LAB_AUTOMATION_HARD_MAX.budgetWindowMs) return state;
+  return {
+    ...state,
+    budgetWindowStartedAt: now,
+    runsThisHour: 0,
+    liveRequestsThisHour: 0,
+  };
+}
+
+function rollingStartedRuns(state: LabAutomationStateV1, now: number): number {
+  const cutoff = now - LAB_AUTOMATION_HARD_MAX.budgetWindowMs;
+  return state.runs.filter((run) => typeof run.startedAt === "number" && run.startedAt > cutoff && run.startedAt <= now).length;
+}
+
+function rollingStartedLiveRuns(state: LabAutomationStateV1, now: number): number {
+  const cutoff = now - LAB_AUTOMATION_HARD_MAX.budgetWindowMs;
+  return state.runs.filter((run) =>
+    run.evidenceLayer === "live_route_compatibility"
+    && typeof run.startedAt === "number"
+    && run.startedAt > cutoff
+    && run.startedAt <= now
+  ).length;
+}
+
+function legacyCounterActive(state: LabAutomationStateV1, now: number): boolean {
+  return now - state.budgetWindowStartedAt < LAB_AUTOMATION_HARD_MAX.budgetWindowMs;
+}
+
+export function runBudgetRemaining(
+  policy: LabAutomationPolicyV1,
+  state: LabAutomationStateV1,
+  now = Date.now(),
+): number {
+  const rolling = rollingStartedRuns(state, now);
+  const legacy = legacyCounterActive(state, now) ? state.runsThisHour : 0;
+  return Math.max(0, policy.maxRunsPerHour - Math.max(rolling, legacy));
+}
+
+export function liveRequestBudgetRemaining(
+  policy: LabAutomationPolicyV1,
+  state: LabAutomationStateV1,
+  now = Date.now(),
+): number {
+  const rolling = rollingStartedLiveRuns(state, now);
+  const legacy = legacyCounterActive(state, now) ? state.liveRequestsThisHour : 0;
+  return Math.max(0, policy.maxLiveRequestsPerHour - Math.max(rolling, legacy));
+}
+
+export function isRunBudgetExhausted(
+  policy: LabAutomationPolicyV1,
+  state: LabAutomationStateV1,
+  now = Date.now(),
+): boolean {
+  return runBudgetRemaining(policy, state, now) <= 0;
+}
+
+export function isLiveRequestBudgetExhausted(
+  policy: LabAutomationPolicyV1,
+  state: LabAutomationStateV1,
+  now = Date.now(),
+): boolean {
+  return liveRequestBudgetRemaining(policy, state, now) <= 0;
+}
+
+/** Legacy persisted counters remain for schema compatibility; startedAt records are rolling authority. */
+export function recordRunBudgetUse(state: LabAutomationStateV1, liveRequest: boolean): LabAutomationStateV1 {
+  return {
+    ...state,
+    runsThisHour: Math.min(LAB_AUTOMATION_HARD_MAX.maxRunsPerHour, state.runsThisHour + 1),
+    liveRequestsThisHour: liveRequest
+      ? Math.min(LAB_AUTOMATION_HARD_MAX.maxLiveRequestsPerHour, state.liveRequestsThisHour + 1)
+      : state.liveRequestsThisHour,
+  };
+}

package/src/lab/automation/config-persistence.ts

@@ -0,0 +1,256 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  linkSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import {
+  ensureLabDirs,
+  labAutomationPolicyPath,
+} from "../paths";
+import { normalizeLabAutomationPolicyV1 } from "./policy";
+import {
+  loadLabAutomationPolicy,
+  loadLabAutomationRoutes,
+  normalizeLabAutomationRoutesV1,
+} from "./persistence";
+import type { LabAutomationPolicyV1, LabAutomationRoutesV1 } from "./types";
+import { LabAutomationError } from "./types";
+
+const CONFIG_SCHEMA_VERSION = 1 as const;
+const CONFIG_KEYS = new Set(["schemaVersion", "policy", "routes"]);
+const CONFIG_LOCK_WAIT_MS = 5_000;
+const LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
+
+interface ConfigLockMeta {
+  pid: number;
+  token: string;
+}
+
+export interface LabAutomationConfigV1 {
+  schemaVersion: typeof CONFIG_SCHEMA_VERSION;
+  policy: LabAutomationPolicyV1;
+  routes: LabAutomationRoutesV1;
+}
+
+type ConfigCommitFault = "before_publish" | null;
+let configCommitFaultForTests: ConfigCommitFault = null;
+
+function configPath(configDir?: string): string {
+  return join(dirname(labAutomationPolicyPath(configDir)), "automation-config.json");
+}
+
+function configLockPath(configDir?: string): string {
+  return `${configPath(configDir)}.lock`;
+}
+
+function sleepLockRetry(): void {
+  Atomics.wait(LOCK_SLEEP, 0, 0, 10);
+}
+
+function readLockMeta(lockPath: string): ConfigLockMeta | null {
+  try {
+    const parsed = JSON.parse(readFileSync(lockPath, "utf8")) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const row = parsed as Record<string, unknown>;
+    if (!Number.isSafeInteger(row.pid) || (row.pid as number) <= 0) return null;
+    if (typeof row.token !== "string" || row.token.length < 16 || row.token.length > 128) return null;
+    return { pid: row.pid as number, token: row.token };
+  } catch {
+    return null;
+  }
+}
+
+function pidDefinitelyDead(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error
+      ? String((error as { code?: unknown }).code)
+      : undefined;
+    return code === "ESRCH";
+  }
+}
+
+function cleanupFile(path: string): void {
+  try {
+    unlinkSync(path);
+  } catch {
+    // Absent or already cleaned.
+  }
+}
+
+function releaseLock(lockPath: string, token: string): void {
+  try {
+    if (readLockMeta(lockPath)?.token === token) unlinkSync(lockPath);
+  } catch {
+    // Already released or replaced.
+  }
+}
+
+function reclaimDeadLock(lockPath: string): boolean {
+  const observed = readLockMeta(lockPath);
+  if (!observed || !pidDefinitelyDead(observed.pid)) return false;
+  const current = readLockMeta(lockPath);
+  if (!current || current.pid !== observed.pid || current.token !== observed.token) return false;
+  try {
+    unlinkSync(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function acquireConfigLock(configDir?: string): () => void {
+  ensureLabDirs(configDir);
+  const lockPath = configLockPath(configDir);
+  const deadline = Date.now() + CONFIG_LOCK_WAIT_MS;
+  while (true) {
+    const token = randomUUID();
+    const privatePath = `${lockPath}.${process.pid}.${token}.tmp`;
+    let publicationAttempted = false;
+    try {
+      const fd = openSync(privatePath, "wx", 0o600);
+      try {
+        writeFileSync(fd, JSON.stringify({ pid: process.pid, token }), { encoding: "utf8" });
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+      publicationAttempted = true;
+      linkSync(privatePath, lockPath);
+      cleanupFile(privatePath);
+      return () => releaseLock(lockPath, token);
+    } catch (error) {
+      cleanupFile(privatePath);
+      const code = error && typeof error === "object" && "code" in error
+        ? String((error as { code?: unknown }).code)
+        : undefined;
+      if (code === "EEXIST" && !publicationAttempted) continue;
+      if (code !== "EEXIST") {
+        throw new LabAutomationError("automation config lock failed", "state_lock_failed");
+      }
+      if (reclaimDeadLock(lockPath)) continue;
+      if (Date.now() >= deadline) {
+        throw new LabAutomationError("automation config is busy", "state_lock_busy");
+      }
+      sleepLockRetry();
+    }
+  }
+}
+
+function withConfigLock<T>(configDir: string | undefined, action: () => T): T {
+  const release = acquireConfigLock(configDir);
+  try {
+    return action();
+  } finally {
+    release();
+  }
+}
+
+function normalizeConfig(raw: unknown): LabAutomationConfigV1 {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new LabAutomationError("automation config must be an object", "invalid_state");
+  }
+  const row = raw as Record<string, unknown>;
+  for (const key of Object.keys(row)) {
+    if (!CONFIG_KEYS.has(key)) {
+      throw new LabAutomationError(`unknown automation config field ${key}`, "invalid_state");
+    }
+  }
+  if (row.schemaVersion !== CONFIG_SCHEMA_VERSION) {
+    throw new LabAutomationError("unsupported automation config schemaVersion", "invalid_state");
+  }
+  return Object.freeze({
+    schemaVersion: CONFIG_SCHEMA_VERSION,
+    policy: normalizeLabAutomationPolicyV1(row.policy),
+    routes: normalizeLabAutomationRoutesV1(row.routes),
+  });
+}
+
+function loadConfigUnlocked(configDir?: string): LabAutomationConfigV1 {
+  ensureLabDirs(configDir);
+  const path = configPath(configDir);
+  if (!existsSync(path)) {
+    return Object.freeze({
+      schemaVersion: CONFIG_SCHEMA_VERSION,
+      policy: loadLabAutomationPolicy(configDir),
+      routes: loadLabAutomationRoutes(configDir),
+    });
+  }
+  try {
+    return normalizeConfig(JSON.parse(readFileSync(path, "utf8")) as unknown);
+  } catch (error) {
+    if (error instanceof LabAutomationError) throw error;
+    throw new LabAutomationError("invalid automation config JSON", "invalid_state");
+  }
+}
+
+function writeConfigUnlocked(
+  policy: LabAutomationPolicyV1,
+  routes: LabAutomationRoutesV1,
+  configDir?: string,
+): LabAutomationConfigV1 {
+  ensureLabDirs(configDir);
+  const normalized = Object.freeze({
+    schemaVersion: CONFIG_SCHEMA_VERSION,
+    policy: normalizeLabAutomationPolicyV1(policy),
+    routes: normalizeLabAutomationRoutesV1(routes),
+  });
+  const path = configPath(configDir);
+  const tmp = join(dirname(path), `.automation-config.${process.pid}.${randomUUID()}.tmp`);
+  let fd: number | null = null;
+  try {
+    fd = openSync(tmp, "wx", 0o600);
+    writeFileSync(fd, JSON.stringify(normalized), { encoding: "utf8" });
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = null;
+    if (configCommitFaultForTests === "before_publish") {
+      throw new LabAutomationError("synthetic automation config commit failure", "invalid_state");
+    }
+    renameSync(tmp, path);
+    return normalized;
+  } finally {
+    if (fd !== null) closeSync(fd);
+    cleanupFile(tmp);
+  }
+}
+
+/** Load one coherent policy/routes generation. */
+export function loadLabAutomationConfig(configDir?: string): LabAutomationConfigV1 {
+  return withConfigLock(configDir, () => loadConfigUnlocked(configDir));
+}
+
+/** Atomically publish one coherent policy/routes generation. */
+export function saveLabAutomationConfig(
+  policy: LabAutomationPolicyV1,
+  routes: LabAutomationRoutesV1,
+  configDir?: string,
+): LabAutomationConfigV1 {
+  return withConfigLock(configDir, () => writeConfigUnlocked(policy, routes, configDir));
+}
+
+/** Update only policy while preserving routes from the same committed generation. */
+export function saveLabAutomationPolicyConfig(
+  policy: LabAutomationPolicyV1,
+  configDir?: string,
+): LabAutomationConfigV1 {
+  return withConfigLock(configDir, () => {
+    const current = loadConfigUnlocked(configDir);
+    return writeConfigUnlocked(policy, current.routes, configDir);
+  });
+}
+
+/** Test-only fault injection before the atomic rename publication point. */
+export function setLabAutomationConfigCommitFaultForTests(fault: ConfigCommitFault): void {
+  configCommitFaultForTests = fault;
+}

package/src/lab/automation/constants.ts

@@ -0,0 +1,39 @@
+/** CL-08 automation hard ceilings — callers cannot raise policy above these values. */
+
+export const LAB_AUTOMATION_POLICY_SCHEMA_VERSION = 1 as const;
+
+export const LAB_AUTOMATION_HARD_MAX = Object.freeze({
+  refreshBeforeStaleMs: 30 * 24 * 60 * 60 * 1000,
+  maxConcurrentRuns: 4,
+  maxConcurrentLiveRuns: 2,
+  maxConcurrentRunsPerRoute: 2,
+  maxRunsPerHour: 60,
+  maxLiveRequestsPerHour: 30,
+  failureCooldownMs: 24 * 60 * 60 * 1000,
+  blockedCooldownMs: 7 * 24 * 60 * 60 * 1000,
+  terminalRunRetentionMs: 7 * 24 * 60 * 60 * 1000,
+  maxQueuedRuns: 256,
+  maxPersistedRuns: 512,
+  maxAutomationRoutes: 64,
+  budgetWindowMs: 60 * 60 * 1000,
+  schedulerTickMs: 60 * 1000,
+});
+
+export const LAB_AUTOMATION_DEFAULT_POLICY = Object.freeze({
+  schemaVersion: LAB_AUTOMATION_POLICY_SCHEMA_VERSION,
+  enabled: false,
+  layers: Object.freeze({
+    protocolConformance: false,
+    liveRouteCompatibility: false,
+    taskEffectiveness: false,
+  }),
+  refreshBeforeStaleMs: 24 * 60 * 60 * 1000,
+  maxConcurrentRuns: 2,
+  maxConcurrentLiveRuns: 1,
+  maxConcurrentRunsPerRoute: 1,
+  maxRunsPerHour: 12,
+  maxLiveRequestsPerHour: 6,
+  failureCooldownMs: 5 * 60 * 1000,
+  blockedCooldownMs: 60 * 60 * 1000,
+  taskEffectivenessBackgroundEnabled: false,
+});

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