chore: merge main into xAI provider branch

Author: harel-coffee

backend/prisma/schema.prisma

@@ -256,6 +256,7 @@ model SupplementalPostScriptRun {
   modelProvider          String?   @map("model_provider")
   harness                String?
   thinkingEffort         String?   @map("thinking_effort")
+  retryOfRunId           BigInt?   @unique(map: "supplemental_post_script_runs_retry_of_run_id_key") @map("retry_of_run_id")
   extra                  Json      @default("{}")
   status                 String    @default("queued")
   targetCount            Int       @default(0) @map("target_count")

backend/src/lib/serialize.js

@@ -471,6 +471,7 @@ export function serializeSupplementalPostScriptRun(run, targets = []) {
     modelProvider: run.modelProvider ?? null,
     harness: run.harness ?? null,
     thinkingEffort: run.thinkingEffort ?? null,
+    retryOfRunId: run.retryOfRunId?.toString() ?? null,
     status: run.status,
     targetCount: run.targetCount,
     completedCount: run.completedCount,

backend/src/routes/scans.js

@@ -218,7 +218,15 @@ function supplementalModelSelection(scan, body = {}, fallbackRun = null) {
   });
 }
 
-async function createSupplementalRunRecords(tx, scanId, postScript, vulnerabilityIds, extra, selection) {
+async function createSupplementalRunRecords(
+  tx,
+  scanId,
+  postScript,
+  vulnerabilityIds,
+  extra,
+  selection,
+  { retryOfRunId = null } = {}
+) {
   const run = await tx.supplementalPostScriptRun.create({
     data: {
       scanId,
@@ -230,6 +238,7 @@ async function createSupplementalRunRecords(tx, scanId, postScript, vulnerabilit
       modelProvider: selection.modelProvider,
       harness: selection.harness,
       thinkingEffort: selection.thinkingEffort,
+      ...(retryOfRunId === null ? {} : { retryOfRunId }),
       extra,
       targetCount: vulnerabilityIds.length,
     },
@@ -306,6 +315,12 @@ export async function retrySupplementalPostScriptRun(tx, scanId, runId, body = {
     return { kind: 'run-active', status: original.status };
   }
 
+  const existingRetry = await tx.supplementalPostScriptRun.findFirst({
+    where: { scanId, retryOfRunId: runId },
+    select: { id: true },
+  });
+  if (existingRetry) return { kind: 'already-retried', retryRunId: existingRetry.id };
+
   const failedTargets = await tx.supplementalPostScriptTarget.findMany({
     where: { runId, scanId, status: 'failed' },
     select: { vulnerabilityId: true },
@@ -339,7 +354,8 @@ export async function retrySupplementalPostScriptRun(tx, scanId, runId, body = {
     },
     vulnerabilityIds,
     original.extra,
-    selection
+    selection,
+    { retryOfRunId: original.id }
   );
 }
 
@@ -802,6 +818,11 @@ router.post('/:id/supplemental-post-script-runs/:runId/retry', async (req, res,
     if (result.kind === 'no-failures') {
       return res.status(409).json({ error: 'This supplemental run has no failed findings to retry.' });
     }
+    if (result.kind === 'already-retried') {
+      return res.status(409).json({
+        error: `These failed findings were already re-run as supplemental run ${result.retryRunId}.`,
+      });
+    }
     res.status(201).json(serializeSupplementalPostScriptRun(result.run, result.targets));
   } catch (e) {
     next(e);

backend/test/dataIntegrity.test.js

@@ -908,20 +908,23 @@ test('supplemental retry clones the snapshot and extras but queues only failed f
       }),
     },
     supplementalPostScriptRun: {
-      findFirst: async () => ({
-        id: 71n,
-        scanId: 9n,
-        status: 'completed_with_errors',
-        postScriptId: 4n,
-        postScriptName: 'Network report',
-        postScriptContent: 'Inspect {{extra.network}}',
-        postScriptOutputFormat: '{"note":"string"}',
-        model: 'old-model',
-        modelProvider: 'codex',
-        harness: 'codex',
-        thinkingEffort: 'medium',
-        extra: { network: 'mainnet' },
-      }),
+      findFirst: async ({ where }) =>
+        where.retryOfRunId
+          ? null
+          : {
+              id: 71n,
+              scanId: 9n,
+              status: 'completed_with_errors',
+              postScriptId: 4n,
+              postScriptName: 'Network report',
+              postScriptContent: 'Inspect {{extra.network}}',
+              postScriptOutputFormat: '{"note":"string"}',
+              model: 'old-model',
+              modelProvider: 'codex',
+              harness: 'codex',
+              thinkingEffort: 'medium',
+              extra: { network: 'mainnet' },
+            },
       create: async ({ data }) => {
         created.push(data);
         return {
@@ -965,6 +968,7 @@ test('supplemental retry clones the snapshot and extras but queues only failed f
     modelProvider: 'openrouter',
     harness: 'codex',
     thinkingEffort: 'high',
+    retryOfRunId: 71n,
     extra: { network: 'mainnet' },
     targetCount: 2,
   });
@@ -974,6 +978,22 @@ test('supplemental retry clones the snapshot and extras but queues only failed f
   );
 });
 
+test('supplemental retry cannot be queued twice from the same failed run', async () => {
+  const tx = {
+    $queryRaw: async () => [],
+    scan: { findUnique: async () => ({ id: 9n, status: 'completed' }) },
+    supplementalPostScriptRun: {
+      findFirst: async ({ where }) =>
+        where.retryOfRunId ? { id: 72n } : { id: 71n, scanId: 9n, status: 'completed_with_errors' },
+    },
+  };
+
+  assert.deepEqual(await retrySupplementalPostScriptRun(tx, 9n, 71n), {
+    kind: 'already-retried',
+    retryRunId: 72n,
+  });
+});
+
 test('supplemental creation rejects scans that can still execute automatically', async () => {
   const tx = {
     $queryRaw: async () => [],

backend/test/scanPresentation.test.js

@@ -80,6 +80,7 @@ test('supplemental run serialization exposes model settings and safe target erro
       modelProvider: 'codex',
       harness: 'codex',
       thinkingEffort: 'high',
+      retryOfRunId: 40n,
       status: 'completed_with_errors',
       targetCount: 1,
       completedCount: 0,
@@ -101,6 +102,7 @@ test('supplemental run serialization exposes model settings and safe target erro
   assert.equal(serialized.model, 'gpt-5-codex');
   assert.equal(serialized.modelProvider, 'codex');
   assert.equal(serialized.thinkingEffort, 'high');
+  assert.equal(serialized.retryOfRunId, '40');
   assert.equal(serialized.targets[0].error, 'The model timed out.');
 });
 

database/init/032_supplemental_post_script_retry_lineage.sql

@@ -0,0 +1,11 @@
+-- Record supplemental retry lineage so each failed run exposes at most one
+-- durable retry action. Additive and idempotent for existing installations.
+
+ALTER TABLE workflows.supplemental_post_script_runs
+    ADD COLUMN IF NOT EXISTS retry_of_run_id bigint;
+
+CREATE UNIQUE INDEX IF NOT EXISTS supplemental_post_script_runs_retry_of_run_id_key
+    ON workflows.supplemental_post_script_runs USING btree (retry_of_run_id);
+
+COMMENT ON COLUMN workflows.supplemental_post_script_runs.retry_of_run_id IS
+    'The failed supplemental run retried by this run; each run can be retried at most once.';

docs-site/scans/post-scripts.mdx

@@ -39,8 +39,10 @@ Supplemental runs are additive. Their output is attached as a new enrichment ins
 replacing an earlier result, and the findings list shows how many additional runs targeted
 each finding. Run progress and finding-level error messages remain visible in **Supplemental
 run history**. A run that completed with errors can requeue only its failed findings; its
-snapshotted script and extra values are reused while the model settings remain editable. A scan
-cannot be resumed or deleted while supplemental targets are queued or running.
+snapshotted script and extra values are reused while the model settings remain editable. Once
+that retry is queued, the original run no longer offers the retry action; if the retry itself
+fails, it can be retried once in turn. A scan cannot be resumed or deleted while supplemental
+targets are queued or running.
 
 <Note>
   Post-scripts are chosen per scan, independent of the workflow - so you can reuse the same

engine/open_kritt_engine/harnesses.py

@@ -178,6 +178,15 @@ class CodexJsonlResult:
     "glm-5.2": "z-ai/glm-5.2",
     "grok-4.5": "x-ai/grok-4.5",
 }
+CLAUDE_OPENROUTER_MODEL_ENV_KEYS = (
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_DEFAULT_MODEL",
+    "ANTHROPIC_DEFAULT_FABLE_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "CLAUDE_CODE_SUBAGENT_MODEL",
+)
 CLAUDE_MODEL_ALIASES = {
     "opus-4.7": "claude-opus-4-7",
     "opus-4.8": "claude-opus-4-8",
@@ -890,6 +899,7 @@ def _scan_docker_command(
         "ANTHROPIC_BASE_URL",
         "ANTHROPIC_AUTH_TOKEN",
         "ANTHROPIC_API_KEY",
+        *CLAUDE_OPENROUTER_MODEL_ENV_KEYS,
         "CODEX_MODEL_PROVIDER",
         "CLAUDE_CODE_MODEL_PROVIDER",
         "CURSOR_API_KEY",
@@ -1041,9 +1051,12 @@ def _claude_env(env: dict[str, str], model: str, model_provider: str | None = No
     if claude_model_provider(model, actual_env, model_provider) == "openrouter":
         if not actual_env.get("OPENROUTER_API_KEY"):
             raise HarnessError("OPENROUTER_API_KEY is required when model provider is openrouter")
+        routed_model = OPENROUTER_MODEL_ALIASES.get(model, model)
         actual_env["ANTHROPIC_BASE_URL"] = actual_env.get("ANTHROPIC_BASE_URL") or OPENROUTER_CLAUDE_BASE_URL
         actual_env["ANTHROPIC_AUTH_TOKEN"] = actual_env.get("ANTHROPIC_AUTH_TOKEN") or actual_env["OPENROUTER_API_KEY"]
         actual_env["ANTHROPIC_API_KEY"] = ""
+        for key in CLAUDE_OPENROUTER_MODEL_ENV_KEYS:
+            actual_env[key] = routed_model
     return actual_env
 
 
@@ -1757,6 +1770,20 @@ def run(
             "--append-system-prompt",
             CLAUDE_WORKSPACE_SYSTEM_PROMPT if allow_tools else CLAUDE_GENERATION_SYSTEM_PROMPT,
         ]
+        if provider == "openrouter":
+            cmd.extend(
+                [
+                    "--settings",
+                    json.dumps(
+                        {
+                            "availableModels": [model],
+                            "enforceAvailableModels": True,
+                            "model": model,
+                        },
+                        separators=(",", ":"),
+                    ),
+                ]
+            )
         if allow_tools:
             cmd.extend(["--dangerously-skip-permissions", "--tools", "default"])
         else:

engine/open_kritt_engine/model_catalog.py

@@ -28,6 +28,9 @@
 XAI_DEFAULT_MODEL_ID = "grok-4.6"
 XAI_THINKING_EFFORTS = ("low", "medium", "high")
 XAI_GROK_46_THINKING_EFFORTS = (*XAI_THINKING_EFFORTS, "xhigh")
+OPENROUTER_MODEL_THINKING_EFFORTS = {
+    "stealth/ox-alpha": ("low", "high", "max"),
+}
 CATALOG_REFRESH_ERROR = "Unable to refresh the provider model catalog."
 MAX_CATALOG_MODELS = 500
 MAX_CATALOG_PAGES = 10
@@ -443,11 +446,14 @@ def fetch_openrouter_models(api_key: str, timeout_seconds: float) -> tuple[list[
         if not model_id or model_id in seen_ids:
             continue
         seen_ids.add(model_id)
+        thinking_efforts = OPENROUTER_MODEL_THINKING_EFFORTS.get(model_id)
         entries.append(
             {
                 "model": model_id,
                 "displayName": raw.get("name"),
-                "supportedReasoningEfforts": _openrouter_thinking_efforts(raw),
+                "supportedReasoningEfforts": (
+                    list(thinking_efforts) if thinking_efforts else _openrouter_thinking_efforts(raw)
+                ),
                 "isDefault": model_id == OPENROUTER_DEFAULT_MODEL_ID,
             }
         )

engine/tests/test_engine.py

@@ -1427,6 +1427,14 @@ def fake_run_process(cmd, prompt, cwd, timeout, env=None):
     assert captured["env"]["ANTHROPIC_BASE_URL"] == "https://openrouter.ai/api"
     assert captured["env"]["ANTHROPIC_AUTH_TOKEN"] == "or-key"
     assert captured["env"]["ANTHROPIC_API_KEY"] == ""
+    for key in harnesses.CLAUDE_OPENROUTER_MODEL_ENV_KEYS:
+        assert captured["env"][key] == "z-ai/glm-5.2"
+    settings = json.loads(captured["cmd"][captured["cmd"].index("--settings") + 1])
+    assert settings == {
+        "availableModels": ["z-ai/glm-5.2"],
+        "enforceAvailableModels": True,
+        "model": "z-ai/glm-5.2",
+    }
     # The subprocess environment is authoritative in both containers and local
     # development; credentials must never be serialized into process arguments.
     if captured["cmd"][:3] == ["runuser", "-u", "nobody"]: