@tangle-network/agent-bench 0.7.1 → 0.8.0

package/src/swe-code-improve.mts

@@ -1,7 +1,7 @@
 /**
  * META-HARNESS on the SWE scaffold — improve({ surface: 'code' }).
  *
- * A coding agent (Claude Code) REWRITES the scaffold LOGIC under bench/src (the seed prompt/playbook,
+ * A Pi coding agent REWRITES the scaffold LOGIC under bench/src (the seed prompt/playbook,
  * runAgentic strategy/params, context handling, retry/patch synthesis) with the MODEL (glm worker) +
  * the TOOL surface (list/read/edit[/run]) + the JUDGE held FIXED, judged on the official swebench
  * Docker verdict, gated on a held-out instance split. This is the DGM/meta-harness recipe: let the
@@ -10,13 +10,9 @@
  * Wiring (all verified in this worktree):
  *   - improve()/codeProposerFor + rawTraceContext come from the LOCAL agent-runtime build, linked into
  *     this bench's node_modules (bench/node_modules/@tangle-network/agent-runtime -> /home/drew/code/agent-runtime).
- *   - The candidate proposer is agenticGenerator(harness:'claude-code'), BUT the shipped runLocalHarness
- *     spawns `claude --headless -p` and --headless is an unknown option on the current CLI (exit 1, no
- *     edits ever). We pass code.generator with a corrected runHarness that spawns
- *     `claude -p <prompt> --dangerously-skip-permissions` so the coding agent can actually edit the
- *     worktree. This is a harness-spawn fix, NOT a hand-authored scaffold edit — Claude still finds the
- *     lever itself from the traces.
- *   - Each candidate is a git worktree the driver forks off baseRef; Claude edits bench/src in place;
+ *   - The candidate proposer supplies one exact Pi AgentProfile and runs it through Runtime's
+ *     bridge executor. No local CLI shortcut or ambient model default exists.
+ *   - Each candidate is a git worktree the driver forks off baseRef; Pi edits bench/src in place;
  *     `verify` (an import smoke of the edited scaffold) gates it before the expensive measurement.
  *   - MEASUREMENT: the code-aware agent fn shells into the candidate scaffold's OWN judge-free emit
  *     entrypoint (swe-emit-patch.mts) with cwd = the worktree, captures the unified diff, and returns
@@ -35,6 +31,7 @@ import { join } from 'node:path'
 import { improve, agenticGenerator } from '@tangle-network/agent-runtime'
 import type { ProposalFinding } from '@tangle-network/agent-eval'
 import type { DispatchContext, JudgeConfig, Scenario } from '@tangle-network/agent-eval/contract'
+import { agentProfileSchema } from '@tangle-network/agent-interface'
 import { createSweBenchAdapter } from './benchmarks/swe-bench'
 import type { BenchTask } from './benchmarks/types'
 
@@ -120,6 +117,22 @@ async function main(): Promise<void> {
   const runDir = process.env.RUN_DIR ?? '/tmp/claude-1000/-home-drew-code-supervisor-lab/9ee6a456-a94f-474c-9888-b4afc9bc26bd/scratchpad/mh-run'
   const emitTimeoutMs = Number(process.env.EMIT_TIMEOUT_MS ?? 600_000)
   const harnessTimeoutMs = Number(process.env.HARNESS_TIMEOUT_MS ?? 900_000)
+  const bridgeUrl = process.env.CLI_BRIDGE_URL ?? process.env.BRIDGE_URL
+  const bridgeBearer = process.env.CLI_BRIDGE_BEARER ?? process.env.BRIDGE_BEARER
+  if (!bridgeUrl || !bridgeBearer) {
+    throw new Error('CLI_BRIDGE_URL/BRIDGE_URL and CLI_BRIDGE_BEARER/BRIDGE_BEARER are required')
+  }
+  const authorProfile = agentProfileSchema.parse({
+    name: 'swe-scaffold-author',
+    harness: 'pi',
+    model: {
+      provider: process.env.AUTHOR_PROVIDER ?? 'tangle-router',
+      default: process.env.AUTHOR_MODEL ?? 'glm-5.2',
+    },
+    prompt: {
+      systemPrompt: 'Improve the candidate worktree from measured failure evidence and verify it.',
+    },
+  })
   mkdirSync(worktreeDir, { recursive: true })
   mkdirSync(runDir, { recursive: true })
 
@@ -199,44 +212,6 @@ async function main(): Promise<void> {
     },
   }
 
-  // The corrected coding-harness spawn: `claude -p <prompt> --dangerously-skip-permissions`. The shipped
-  // runLocalHarness uses `claude --headless -p` (unknown option on this CLI). agenticGenerator ignores
-  // the return value (it reads worktree dirtiness), so a minimal result shape is enough.
-  const runHarness = (o: { cwd: string; taskPrompt: string; timeoutMs?: number; signal?: AbortSignal }): Promise<{ exitCode: number | null; stdout: string; stderr: string; killedBySignal: NodeJS.Signals | null; durationMs: number; timedOut: boolean }> => {
-    const started = Date.now()
-    return new Promise((resolve) => {
-      const child = spawn('claude', ['-p', o.taskPrompt, '--dangerously-skip-permissions'], {
-        cwd: o.cwd,
-        env: process.env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
-      let stdout = ''
-      let stderr = ''
-      let timedOut = false
-      child.stdout?.on('data', (d) => (stdout += String(d)))
-      child.stderr?.on('data', (d) => (stderr += String(d)))
-      const timer = setTimeout(() => {
-        timedOut = true
-        if (!child.killed) child.kill('SIGTERM')
-      }, o.timeoutMs ?? harnessTimeoutMs)
-      ;(timer as { unref?: () => void }).unref?.()
-      const onAbort = () => {
-        if (!child.killed) child.kill('SIGTERM')
-      }
-      o.signal?.addEventListener('abort', onAbort, { once: true })
-      child.on('error', () => {
-        clearTimeout(timer)
-        resolve({ exitCode: 1, stdout, stderr: `${stderr}\n[spawn error]`, killedBySignal: null, durationMs: Date.now() - started, timedOut })
-      })
-      child.on('close', (code, signal) => {
-        clearTimeout(timer)
-        o.signal?.removeEventListener('abort', onAbort)
-        console.error(`  [proposer:claude] exit=${code} wall=${Math.round((Date.now() - started) / 1000)}s out=${stdout.length}b`)
-        resolve({ exitCode: code, stdout, stderr, killedBySignal: signal, durationMs: Date.now() - started, timedOut })
-      })
-    })
-  }
-
   // Domain prompt: name the EDIT BOUNDARY (scaffold logic only) + keep the raw-trace evidence discipline
   // (agenticGenerator discards a raw-trace candidate that doesn't inspect a trace + write the diagnosis).
   const buildPrompt = (args: { findings: ReadonlyArray<ProposalFinding> }): string => {
@@ -286,13 +261,16 @@ async function main(): Promise<void> {
   }
 
   const generator = agenticGenerator({
-    harness: 'claude-code',
+    profile: authorProfile,
+    executorForWorktree: (cwd) => ({
+      backend: 'bridge',
+      bridgeUrl,
+      bridgeBearer,
+      cwd,
+    }),
     verify,
     timeoutMs: harnessTimeoutMs,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    buildPrompt: buildPrompt as any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    runHarness: runHarness as any,
+    buildPrompt,
   })
 
   const scenarios: Scenario[] = allIds.map((id) => ({ id, kind: 'swe-bench-verified' }))
@@ -301,7 +279,7 @@ async function main(): Promise<void> {
   const out = await improve({
     surface: 'code',
     gate: 'holdout',
-    code: { repoRoot: REPO_ROOT, baseRef, worktreeDir, generator },
+    code: { repoRoot: REPO_ROOT, baseRef, worktreeDir, profile: authorProfile, generator },
     rawTraceContext: true,
     runDir,
     scenarios,

package/src/swe-emit-patch.mts

@@ -23,8 +23,9 @@
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 import type { AgenticSurface, ArtifactHandle, SurfaceScore } from '@tangle-network/agent-runtime/kernel'
-import { refine, runAgentic } from '@tangle-network/agent-runtime/kernel'
+import { defaultAnalystInstruction, refine, runAgentic } from '@tangle-network/agent-runtime/kernel'
 import { createSweBenchEnvironment, SWE_SEED_PROMPT, SWE_SEED_PROMPT_WITH_RUN } from './swe-bench-env'
+import { benchRouterProfile, withBenchProfile } from './router-turn'
 
 const exec = promisify(execFile)
 
@@ -56,10 +57,31 @@ async function main(): Promise<void> {
 
   const task = {
     id: bt.id,
-    systemPrompt: enableRun ? SWE_SEED_PROMPT_WITH_RUN : SWE_SEED_PROMPT,
     userPrompt: bt.prompt,
     meta: { instanceId: bt.id },
   }
+  const workerProfile = withBenchProfile(
+    {
+      name: 'swe-emit-patch-worker',
+      harness: 'cli-base',
+      model: { provider: 'tangle-router', default: model },
+      tools: {
+        list_files: true,
+        read_file: true,
+        edit_file: true,
+        ...(enableRun ? { run: true } : {}),
+      },
+    },
+    {
+      systemPrompt: enableRun ? SWE_SEED_PROMPT_WITH_RUN : SWE_SEED_PROMPT,
+      maxTokens,
+      maxTurns: innerTurns,
+    },
+  )
+  const analystProfile = benchRouterProfile('swe-emit-patch-analyst', model, {
+    systemPrompt: defaultAnalystInstruction,
+    maxTokens,
+  })
 
   // Capture the patch from inside score() (called during the refine loop, BEFORE the surface closes
   // and rms the checkout). Keep the LATEST non-empty diff so accumulated refinements win and a later
@@ -85,9 +107,8 @@ async function main(): Promise<void> {
     strategy: refine,
     routerBaseUrl,
     routerKey,
-    model,
-    maxTokens,
-    innerTurns,
+    workerProfile,
+    analystProfile,
     budget,
   })
   const files = capturedPatch ? [...capturedPatch.matchAll(/^diff --git a\/(\S+)/gm)].map((m) => m[1]) : []

package/src/swe-improve.mts

@@ -30,10 +30,11 @@ import {
 } from '@tangle-network/agent-runtime'
 import {
   canonicalCandidateDigest,
+  agentProfileSchema,
   type AgentProfile,
 } from '@tangle-network/agent-interface'
 import type { AgenticSurface, ArtifactHandle, SurfaceScore } from '@tangle-network/agent-runtime/kernel'
-import { refine, runAgentic } from '@tangle-network/agent-runtime/kernel'
+import { defaultAnalystInstruction, refine, runAgentic } from '@tangle-network/agent-runtime/kernel'
 import type { DispatchContext, JudgeConfig, Scenario } from '@tangle-network/agent-eval/contract'
 import { createSweBenchAdapter } from './benchmarks/swe-bench'
 import type { BenchTask } from './benchmarks/types'
@@ -43,6 +44,7 @@ import {
   requiredTokenPricing,
 } from './official-optimizer-config.mjs'
 import { createSweBenchEnvironment, SWE_SEED_PROMPT, SWE_SEED_PROMPT_WITH_RUN } from './swe-bench-env'
+import { benchRouterProfile, withBenchProfile } from './router-turn'
 
 const exec = promisify(execFile)
 
@@ -70,6 +72,24 @@ async function main(): Promise<void> {
   const enableRun = ['1', 'true', 'yes'].includes((process.env.RUN_TOOL ?? '').toLowerCase())
   const SEED_PROMPT = enableRun ? SWE_SEED_PROMPT_WITH_RUN : SWE_SEED_PROMPT
   const allIds = [...new Set([...trainIds, ...selectionIds, ...testIds])]
+  const workerProfile = withBenchProfile(
+    {
+      name: 'swe-agent-worker',
+      harness: 'cli-base',
+      model: { provider: 'tangle-router', default: workerModel },
+      tools: {
+        list_files: true,
+        read_file: true,
+        edit_file: true,
+        ...(enableRun ? { run: true } : {}),
+      },
+    },
+    { systemPrompt: SEED_PROMPT, maxTokens: workerMaxTokens, maxTurns: innerTurns },
+  )
+  const analystProfile = benchRouterProfile('swe-agent-analyst', workerModel, {
+    systemPrompt: defaultAnalystInstruction,
+    maxTokens: workerMaxTokens,
+  })
 
   console.log('=== SWE-bench prompt optimization with official GEPA ===')
   console.log(`worker=${workerModel} reflect=${reflectModel} router=${routerBaseUrl}`)
@@ -103,11 +123,12 @@ async function main(): Promise<void> {
   // score() BEFORE runAgentic closes (rm) the workspace; its score is a cheap
   // patch-exists proxy so the ONLY Docker run per cell is the improve judge.
   const agent = async (candidate: ReadonlyAgentProfile, scenario: Scenario, ctx: DispatchContext): Promise<string | null> => {
-    const promptText = candidate.prompt?.systemPrompt
+    const exactCandidate = agentProfileSchema.parse(candidate)
+    const promptText = exactCandidate.prompt?.systemPrompt
     if (promptText === undefined) throw new Error('agent: candidate profile has no system prompt')
     const bt = byId.get(scenario.id)
     if (!bt) throw new Error(`agent: unknown scenario ${scenario.id}`)
-    const task = { id: bt.id, systemPrompt: promptText, userPrompt: bt.prompt, meta: { instanceId: bt.id } }
+    const task = { id: bt.id, userPrompt: bt.prompt, meta: { instanceId: bt.id } }
     let capturedPatch = ''
     const stats = { list: 0, read: 0, edit_ok: 0, edit_fail: 0, run: 0, run_err: 0 }
     const proxy: AgenticSurface = {
@@ -143,9 +164,8 @@ async function main(): Promise<void> {
           strategy: refine,
           routerBaseUrl,
           routerKey,
-          model: workerModel,
-          maxTokens: workerMaxTokens,
-          innerTurns,
+          workerProfile: exactCandidate,
+          analystProfile,
           budget: budgetShots,
         }),
       receipt: (result) => {
@@ -201,10 +221,9 @@ async function main(): Promise<void> {
     },
   }
 
-  const profile: AgentProfile = { name: 'swe-agent-glm46', prompt: { systemPrompt: SEED_PROMPT } }
   const scenario = (id: string): Scenario => ({ id, kind: 'swe-bench-verified' })
 
-  const out = await improve(profile, {
+  const out = await improve(workerProfile, {
     surface: 'prompt',
     executionRef: canonicalCandidateDigest({
       callback: 'bench/swe-improve',

package/src/swe-jail.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { zaiChatRaw } from './swe-jail'
+
+test('zaiChatRaw preserves the SWE transport shape through Runtime', async () => {
+  const originalFetch = globalThis.fetch
+  let requestBody: Record<string, unknown> | undefined
+  let requestUrl = ''
+  globalThis.fetch = async (input, init) => {
+    requestUrl = String(input)
+    requestBody = JSON.parse(String(init?.body)) as Record<string, unknown>
+    return new Response(
+      JSON.stringify({
+        choices: [
+          {
+            message: {
+              content: null,
+              tool_calls: [
+                {
+                  id: 'call-1',
+                  type: 'function',
+                  function: { name: 'run', arguments: '{"command":"pwd"}' },
+                },
+              ],
+            },
+          },
+        ],
+        usage: { prompt_tokens: 11, completion_tokens: 3 },
+      }),
+      { status: 200, headers: { 'content-type': 'application/json' } },
+    )
+  }
+
+  try {
+    const result = await zaiChatRaw(
+      { base: 'http://router.test/v1', key: 'secret', timeoutMs: 1_000 },
+      {
+        model: 'deepseek-v4-flash',
+        messages: [{ role: 'user', content: 'inspect' }],
+        tools: [
+          {
+            type: 'function',
+            function: { name: 'run', parameters: { type: 'object' } },
+          },
+        ],
+        tool_choice: 'required',
+        temperature: 0.1,
+        max_tokens: 32_768,
+        thinking: { type: 'enabled' },
+      },
+      {
+        name: 'swe-jail-test-worker',
+        harness: 'cli-base',
+        model: { provider: 'tangle-router', default: 'deepseek-v4-flash' },
+        tools: { run: true },
+      },
+    )
+
+    assert.equal(requestUrl, 'http://router.test/v1/chat/completions')
+    assert.deepEqual(requestBody, {
+      model: 'deepseek-v4-flash',
+      messages: [{ role: 'user', content: 'inspect' }],
+      tools: [
+        {
+          type: 'function',
+          function: { name: 'run', parameters: { type: 'object' } },
+        },
+      ],
+      tool_choice: 'required',
+      temperature: 0.1,
+      max_tokens: 32_768,
+      thinking: { type: 'enabled' },
+    })
+    assert.equal(result.attempts, 1)
+    assert.deepEqual(result.json, {
+      choices: [
+        {
+          message: {
+            role: 'assistant',
+            content: null,
+            tool_calls: [
+              {
+                id: 'call-1',
+                type: 'function',
+                function: { name: 'run', arguments: '{"command":"pwd"}' },
+              },
+            ],
+          },
+          finish_reason: 'tool_calls',
+        },
+      ],
+      usage: { prompt_tokens: 11, completion_tokens: 3 },
+    })
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('zaiChatRaw refuses a local profile error without entering the retry ladder', async () => {
+  let fetchCalls = 0
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async () => {
+    fetchCalls += 1
+    throw new Error('fetch must not run')
+  }
+
+  try {
+    await assert.rejects(
+      zaiChatRaw(
+        {
+          base: 'http://router.test/v1',
+          key: 'secret',
+          timeoutMs: 1_000,
+          maxAttempts: 7,
+        },
+        { model: 'deepseek-v4-flash', messages: [{ role: 'user', content: 'inspect' }] },
+        {
+          name: 'incomplete-worker',
+          model: { provider: 'tangle-router', default: 'deepseek-v4-flash' },
+        },
+      ),
+      /AgentProfile\.harness must be explicit/,
+    )
+    assert.equal(fetchCalls, 0)
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})

package/src/swe-jail.ts

@@ -12,12 +12,15 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
+import type { AgentProfile } from '@tangle-network/agent-interface'
+import type { ToolSpec } from '@tangle-network/agent-runtime/kernel'
+import { runBenchRouterTurn, withBenchProfile } from './router-turn'
 
 const exec = promisify(execFile)
 
 export const tail = (s: string, n: number): string => (s.length > n ? `…${s.slice(s.length - n)}` : s)
 
-// ---------- zai chat client (plain fetch; patient 429 ladder) ----------
+// ---------- zai chat client (Runtime transport; patient 429 ladder) ----------
 
 export interface ZaiCfg {
   base: string
@@ -27,12 +30,14 @@ export interface ZaiCfg {
    *  runs — past this instant, so a per-instance deadline reaches INTO the 429 ladder instead of
    *  letting a doomed retry sleep for another 240s after the instance was already written off. */
   deadlineAt?: number
+  /** Caller-owned retry ladder length. Default 7. */
+  maxAttempts?: number
 }
 
 export interface ZaiRaw {
-  /** The parsed /chat/completions JSON, verbatim. */
+  /** The OpenAI-compatible message and usage fields expected by existing SWE callers. */
   json: Record<string, unknown>
-  /** HTTP attempts spent (retries included). */
+  /** Runtime completion attempts spent (retries included). */
   attempts: number
 }
 
@@ -44,10 +49,39 @@ export interface ZaiRaw {
  * tool_calls — is the glm reasoning path starving `content` when reasoning eats max_tokens, and is
  * retried too (a tool_calls turn with empty content is a NORMAL tool-loop turn, not starvation).
  */
-export async function zaiChatRaw(cfg: ZaiCfg, body: Record<string, unknown>): Promise<ZaiRaw> {
+export async function zaiChatRaw(
+  cfg: ZaiCfg,
+  body: Record<string, unknown>,
+  profile: AgentProfile,
+): Promise<ZaiRaw> {
+  const {
+    model,
+    messages,
+    tools,
+    temperature,
+    max_tokens: maxTokens,
+    tool_choice: toolChoice,
+    ...extraBody
+  } = body
+  if (typeof model !== 'string' || model.length === 0) {
+    throw new Error('completion body.model must be a non-empty string')
+  }
+  if (profile.model?.default !== model) {
+    throw new Error('completion body.model must equal AgentProfile.model.default')
+  }
+  if (!Array.isArray(messages)) throw new Error('completion body.messages must be an array')
+  const typedTools = Array.isArray(tools) ? (tools as ToolSpec[]) : []
+  const typedToolChoice =
+    toolChoice === 'auto' || toolChoice === 'required' || toolChoice === 'none'
+      ? toolChoice
+      : undefined
   let lastErr = ''
   let delayBase = 2_000
-  for (let attempt = 1; attempt <= 7; attempt += 1) {
+  const maxAttempts = cfg.maxAttempts ?? 7
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error('ZaiCfg.maxAttempts must be a positive safe integer')
+  }
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     if (attempt > 1) {
       const delay = Math.min(delayBase * 2 ** (attempt - 2), 240_000)
       if (cfg.deadlineAt !== undefined && Date.now() + delay >= cfg.deadlineAt) {
@@ -63,30 +97,80 @@ export async function zaiChatRaw(cfg: ZaiCfg, body: Record<string, unknown>): Pr
     const ctl = new AbortController()
     const timer = setTimeout(() => ctl.abort(), perCallTimeout)
     try {
-      const res = await fetch(`${cfg.base}/chat/completions`, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: ctl.signal,
-      })
-      if (!res.ok) {
-        lastErr = `HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`
-        delayBase = res.status === 429 ? 60_000 : 2_000
-        continue
-      }
-      const json = (await res.json()) as Record<string, unknown>
-      const msg = ((json.choices as Array<{ message?: Record<string, unknown> }> | undefined)?.[0]?.message ?? {}) as {
-        content?: string
-        tool_calls?: unknown[]
+      const result = await runBenchRouterTurn(
+        {
+          routerBaseUrl: cfg.base,
+          routerKey: cfg.key,
+          profile: withBenchProfile(profile, {
+            ...(typeof temperature === 'number' ? { temperature } : {}),
+            ...(typeof maxTokens === 'number' ? { maxTokens } : {}),
+            ...(typedToolChoice ? { toolChoice: typedToolChoice } : {}),
+            extraBody,
+          }),
+          tools: typedTools,
+          signal: ctl.signal,
+        },
+        { messages: messages as Array<Record<string, unknown>> },
+      )
+      const toolCalls = result.toolCalls.map((call, index) => ({
+        id: call.id ?? `call_${index}`,
+        name: call.name,
+        arguments: call.arguments,
+      }))
+      const message = {
+        role: 'assistant',
+        content: toolCalls.length > 0 && result.finalText === '' ? null : result.finalText,
+        ...(toolCalls.length > 0
+          ? {
+              tool_calls: toolCalls.map((call) => ({
+                id: call.id,
+                type: 'function',
+                function: { name: call.name, arguments: call.arguments },
+              })),
+            }
+          : {}),
       }
-      const hasToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0
-      if (!hasToolCalls && String(msg.content ?? '').trim() === '') {
+      if (toolCalls.length === 0 && result.finalText.trim() === '') {
         lastErr = 'empty content'
         continue
       }
+      const finalEvent = result.events.at(-1)
+      const finishReason =
+        finalEvent?.type === 'final'
+          ? finalEvent.reason
+          : toolCalls.length > 0
+            ? 'tool_calls'
+            : 'stop'
+      const json: Record<string, unknown> = {
+        choices: [
+          {
+            message,
+            finish_reason: finishReason,
+          },
+        ],
+        ...(result.usage.tokensKnown !== false
+          ? {
+              usage: {
+                prompt_tokens: result.usage.input,
+                completion_tokens: result.usage.output,
+              },
+            }
+          : {}),
+      }
       return { json, attempts: attempt }
     } catch (e) {
       lastErr = e instanceof Error ? e.message : String(e)
+      const status = Number(/router (\d+)/.exec(lastErr)?.[1])
+      const transientStatus =
+        Number.isFinite(status) &&
+        (status === 408 || status === 409 || status === 425 || status === 429 || status >= 500)
+      const transientTransport =
+        ctl.signal.aborted ||
+        /fetch failed|network|socket|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|operation was aborted/i.test(
+          lastErr,
+        )
+      if (!transientStatus && !transientTransport) throw e
+      delayBase = status === 429 ? 60_000 : 2_000
     } finally {
       clearTimeout(timer)
     }

package/src/swe-local-proof.mts

@@ -21,9 +21,10 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
 import type { AgenticSurface, ArtifactHandle, SurfaceScore } from '@tangle-network/agent-runtime/kernel'
-import { refine, runAgentic } from '@tangle-network/agent-runtime/kernel'
+import { defaultAnalystInstruction, refine, runAgentic } from '@tangle-network/agent-runtime/kernel'
 import type { BenchScore } from './benchmarks/types'
-import { createSweBenchEnvironment } from './swe-bench-env'
+import { createSweBenchEnvironment, SWE_SEED_PROMPT, SWE_SEED_PROMPT_WITH_RUN } from './swe-bench-env'
+import { benchRouterProfile, withBenchProfile } from './router-turn'
 
 const exec = promisify(execFile)
 
@@ -45,6 +46,28 @@ async function main(): Promise<void> {
   console.log(`router=${routerBaseUrl}`)
 
   const { environment, tasks, adapter } = await createSweBenchEnvironment(ids.length, { ids, enableRun })
+  const workerProfile = withBenchProfile(
+    {
+      name: 'swe-local-proof-worker',
+      harness: 'cli-base',
+      model: { provider: 'tangle-router', default: model },
+      tools: {
+        list_files: true,
+        read_file: true,
+        edit_file: true,
+        ...(enableRun ? { run: true } : {}),
+      },
+    },
+    {
+      systemPrompt: enableRun ? SWE_SEED_PROMPT_WITH_RUN : SWE_SEED_PROMPT,
+      maxTokens,
+      maxTurns: innerTurns,
+    },
+  )
+  const analystProfile = benchRouterProfile('swe-local-proof-analyst', model, {
+    systemPrompt: defaultAnalystInstruction,
+    maxTokens,
+  })
   const taskList = await tasks(0, ids.length)
   const benchTaskById = new Map(
     (await adapter.loadTasks({ ids, split: 'test' })).map((task) => [task.id, task]),
@@ -145,9 +168,8 @@ async function main(): Promise<void> {
       strategy: refine,
       routerBaseUrl,
       routerKey,
-      model,
-      maxTokens,
-      innerTurns,
+      workerProfile,
+      analystProfile,
       budget,
     })
     const rec = captured.get(task.id)

package/src/swe-repro-calibrate.mts

@@ -89,6 +89,11 @@ async function complete(messages: ChatMsg[]): Promise<Completion> {
   const { json, attempts } = await zaiChatRaw(
     { base: ZAI_BASE, key: ZAI_KEY, timeoutMs: LLM_TIMEOUT_MS },
     { model: MODEL, max_tokens: MAX_TOKENS, temperature: TEMP, messages },
+    {
+      name: 'swe-reproduction-calibrator',
+      model: { provider: 'zai', default: MODEL, reasoningEffort: 'high' },
+      prompt: { systemPrompt: AUTHOR_SYSTEM },
+    },
   )
   const d = json as {
     choices?: Array<{ message?: { content?: string } }>