@tangle-network/agent-bench 0.7.1 → 0.8.0

package/src/swe-self-improve.mts

@@ -9,17 +9,42 @@
  */
 import { mkdtempSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
-import { createChatClient } from '@tangle-network/agent-eval'
-import { refine, runAgentic, runStrategyEvolution, sample } from '@tangle-network/agent-runtime/kernel'
+import type { AgentProfile } from '@tangle-network/agent-interface'
+import {
+  refine,
+  runAgentic,
+  runStrategyEvolution,
+  sample,
+  strategyAuthorSystemPrompt,
+} from '@tangle-network/agent-runtime/kernel'
 import { createSweBenchEnvironment } from './swe-bench-env'
 
 async function main(): Promise<void> {
   const routerKey = process.env.TANGLE_API_KEY
   if (!routerKey) throw new Error('TANGLE_API_KEY required (worker + author call the router)')
   const routerBaseUrl = process.env.ROUTER_BASE ?? 'https://router.tangle.tools/v1'
-  const workerModel = process.env.WORKER_MODEL ?? 'gemini-2.5-pro'
-  const authorModel = process.env.AUTHOR_MODEL ?? 'gemini-2.5-pro'
+  const workerModel = process.env.WORKER_MODEL ?? 'deepseek-v4-flash'
+  const authorModel = process.env.AUTHOR_MODEL ?? 'deepseek-v4-flash'
   const innerTurns = Number(process.env.INNER_TURNS ?? 40)
+  const workerProfile: AgentProfile = {
+    name: 'swe-worker',
+    harness: 'cli-base',
+    model: {
+      provider: 'tangle-router',
+      default: workerModel,
+      metadata: { maxTokens: 8000, maxTurns: innerTurns },
+    },
+  }
+  const authorProfile = (model: string, name: string): AgentProfile => ({
+    name,
+    harness: 'cli-base',
+    model: {
+      provider: 'tangle-router',
+      default: model,
+      metadata: { maxTokens: 8000 },
+    },
+    prompt: { systemPrompt: strategyAuthorSystemPrompt },
+  })
   const { environment, tasks } = await createSweBenchEnvironment(Number(process.env.POOL_N ?? 80))
 
   if (process.env.CALIBRATE === '1') {
@@ -29,7 +54,15 @@ async function main(): Promise<void> {
     let resolved = 0
     for (const t of ts) {
       const t0 = Date.now()
-      const r = await runAgentic({ surface: environment, task: t, strategy: refine, routerBaseUrl, routerKey, model: workerModel, maxTokens: 8000, innerTurns, budget: 1 })
+      const r = await runAgentic({
+        surface: environment,
+        task: t,
+        strategy: refine,
+        routerBaseUrl,
+        routerKey,
+        workerProfile,
+        budget: 1,
+      })
       if (r.resolved) resolved++
       console.log(`  ${t.id.padEnd(32)} resolved=${r.resolved} completions=${r.completions} shots=${r.shots} (${Math.round((Date.now() - t0) / 1000)}s)`)
     }
@@ -46,12 +79,14 @@ async function main(): Promise<void> {
         tasks,
         trainN: Number(process.env.TRAIN_N ?? 6),
         holdoutN: Number(process.env.HOLDOUT_N ?? 8),
-        worker: { routerBaseUrl, routerKey, model: workerModel, maxTokens: 8000, innerTurns },
+        worker: { routerBaseUrl, routerKey, workerProfile },
         author: {
-          chat: createChatClient({ transport: 'router', baseUrl: routerBaseUrl, apiKey: routerKey, defaultModel: authorModel }),
-          model: authorModel,
-          maxTokens: 8000,
-          fallbackModel: process.env.AUTHOR_FALLBACK ?? 'deepseek-v4-flash',
+          profile: authorProfile(authorModel, 'swe-strategy-author'),
+          executor: { backend: 'router', routerBaseUrl, routerKey },
+          fallbackProfile: authorProfile(
+            process.env.AUTHOR_FALLBACK ?? 'deepseek-v4-flash',
+            'swe-strategy-author-fallback',
+          ),
         },
         baselines: [sample, refine],
         budget: Number(process.env.BUDGET ?? 2),

package/src/swe-stream.mts

@@ -66,7 +66,7 @@ import { join } from 'node:path'
 import { promisify } from 'node:util'
 import { applyKnowledgeWriteBlocks, buildKnowledgeIndex, initKnowledgeBase, searchKnowledge } from '@tangle-network/agent-knowledge'
 import type { AgenticSurface, AgenticTask, 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 { BenchTask } from './benchmarks/types'
 import { createSweBenchEnvironment, resolveImageForMetadata, SWE_SEED_PROMPT } from './swe-bench-env'
 import {
@@ -82,6 +82,7 @@ import {
   tail,
   zaiChatRaw,
 } from './swe-jail'
+import { withBenchProfile } from './router-turn'
 
 const exec = promisify(execFile)
 
@@ -274,9 +275,29 @@ const makeTransport =
     counter.guardedMsgs += assertNoHiddenLeak(marks, msgs)
     // Inject the honored reasoning-budget knob (thinking) here at the single shared worker
     // chokepoint: makeTransport is byte-identical across arms F and L, so the budget is symmetric.
+    const model = String(body.model ?? '')
+    const systemPrompt = msgs.find((message) => message.role === 'system')?.content
+    const toolNames = Array.isArray(body.tools)
+      ? (body.tools as Array<{ function?: { name?: unknown } }>).flatMap((tool) =>
+          typeof tool.function?.name === 'string' ? [tool.function.name] : [],
+        )
+      : []
     const { json, attempts } = await zaiChatRaw(
       { base: ZAI_BASE, key: ZAI_KEY, timeoutMs: LLM_TIMEOUT_MS, deadlineAt: guard.deadlineAt },
       { ...body, ...WORKER_REASONING },
+      {
+        name: 'swe-stream-worker',
+        harness: 'cli-base',
+        model: {
+          provider: 'zai',
+          default: model,
+          reasoningEffort: REASONING_ON ? 'high' : 'none',
+        },
+        ...(typeof systemPrompt === 'string' ? { prompt: { systemPrompt } } : {}),
+        ...(toolNames.length > 0
+          ? { tools: Object.fromEntries(toolNames.map((name) => [name, true])) }
+          : {}),
+      },
     )
     counter.calls += 1
     counter.httpAttempts += attempts
@@ -345,10 +366,44 @@ async function emitAttempt(
   }
   const task: AgenticTask = {
     id: bt.id,
-    systemPrompt: SWE_SEED_PROMPT,
     userPrompt: cfg.promptAppendix ? `${bt.prompt}\n\n${cfg.promptAppendix}` : bt.prompt,
     meta: { instanceId: bt.id },
   }
+  const workerProfile = withBenchProfile(
+    {
+      name: 'swe-stream-worker',
+      harness: 'cli-base',
+      model: {
+        provider: 'zai',
+        default: WORKER_MODEL,
+        reasoningEffort: REASONING_ON ? 'high' : 'none',
+      },
+      tools: { list_files: true, read_file: true, edit_file: true },
+    },
+    {
+      systemPrompt: SWE_SEED_PROMPT,
+      maxTokens: MAX_TOKENS,
+      maxTurns: INNER_TURNS,
+      temperature: cfg.temperature,
+      extraBody: WORKER_REASONING,
+    },
+  )
+  const analystProfile = withBenchProfile(
+    {
+      name: 'swe-stream-analyst',
+      harness: 'cli-base',
+      model: {
+        provider: 'zai',
+        default: WORKER_MODEL,
+        reasoningEffort: REASONING_ON ? 'high' : 'none',
+      },
+    },
+    {
+      systemPrompt: defaultAnalystInstruction,
+      maxTokens: MAX_TOKENS,
+      extraBody: WORKER_REASONING,
+    },
+  )
   let error: string | undefined
   try {
     const r = await runAgentic({
@@ -357,10 +412,8 @@ async function emitAttempt(
       strategy: refine,
       routerBaseUrl: 'zai-direct', // unused: the `complete` transport short-circuits the router
       routerKey: 'zai-direct',
-      model: WORKER_MODEL,
-      maxTokens: MAX_TOKENS,
-      temperature: cfg.temperature,
-      innerTurns: INNER_TURNS,
+      workerProfile,
+      analystProfile,
       budget: 1,
       complete: makeTransport(cfg.marks, counter, guard),
     })
@@ -643,6 +696,11 @@ async function acquireRepro(
       const { json } = await zaiChatRaw(
         { base: ZAI_BASE, key: ZAI_KEY, timeoutMs: LLM_TIMEOUT_MS, deadlineAt },
         { model: REPRO_MODEL, max_tokens: MAX_TOKENS, temperature: 0.2, messages },
+        {
+          name: 'swe-reproduction-author',
+          model: { provider: 'zai', default: REPRO_MODEL, reasoningEffort: 'high' },
+          prompt: { systemPrompt: reproAuthorSystem(REPRO_TIMEOUT_S) },
+        },
       )
       const d = json as { choices?: Array<{ message?: { content?: string } }>; usage?: { prompt_tokens?: number; completion_tokens?: number } }
       out.authorCalls += 1
@@ -810,6 +868,10 @@ async function superviseRepair(
     const { json, attempts } = await zaiChatRaw(
       { base: ZAI_BASE, key: ZAI_KEY, timeoutMs: LLM_TIMEOUT_MS, deadlineAt },
       { model: SUPERVISOR_MODEL, max_tokens: SUPERVISOR_MAX_TOKENS, temperature: 0.2, messages },
+      {
+        name: 'swe-repair-supervisor',
+        model: { provider: 'zai', default: SUPERVISOR_MODEL, reasoningEffort: 'high' },
+      },
     )
     const d = json as { choices?: Array<{ message?: { content?: string } }>; usage?: { prompt_tokens?: number; completion_tokens?: number } }
     const planRaw = d.choices?.[0]?.message?.content ?? ''

package/src/swe-structural.mts

@@ -50,7 +50,7 @@ import { appendFileSync, existsSync, readFileSync, rmSync, writeFileSync } from
 import { join } from 'node:path'
 import { promisify } from 'node:util'
 import type { AgenticSurface, AgenticTask, 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 { BenchTask } from './benchmarks/types'
 import { createSweBenchEnvironment, resolveImageForMetadata, SWE_SEED_PROMPT } from './swe-bench-env'
 import {
@@ -63,6 +63,7 @@ import {
   tail,
   zaiChatRaw,
 } from './swe-jail'
+import { withBenchProfile } from './router-turn'
 
 const exec = promisify(execFile)
 
@@ -138,7 +139,26 @@ const makeTransport =
   async (body: Record<string, unknown>): Promise<unknown> => {
     const msgs = (body.messages ?? []) as Array<{ role?: string; content?: unknown }>
     counter.guardedMsgs += assertNoHiddenLeak(marks, msgs)
-    const { json, attempts } = await zaiChatRaw({ base: ZAI_BASE, key: ZAI_KEY, timeoutMs: LLM_TIMEOUT_MS }, body)
+    const model = String(body.model ?? '')
+    const systemPrompt = msgs.find((message) => message.role === 'system')?.content
+    const toolNames = Array.isArray(body.tools)
+      ? (body.tools as Array<{ function?: { name?: unknown } }>).flatMap((tool) =>
+          typeof tool.function?.name === 'string' ? [tool.function.name] : [],
+        )
+      : []
+    const { json, attempts } = await zaiChatRaw(
+      { base: ZAI_BASE, key: ZAI_KEY, timeoutMs: LLM_TIMEOUT_MS },
+      body,
+      {
+        name: 'swe-structural-worker',
+        harness: 'cli-base',
+        model: { provider: 'zai', default: model, reasoningEffort: 'high' },
+        ...(typeof systemPrompt === 'string' ? { prompt: { systemPrompt } } : {}),
+        ...(toolNames.length > 0
+          ? { tools: Object.fromEntries(toolNames.map((name) => [name, true])) }
+          : {}),
+      },
+    )
     counter.calls += 1
     counter.httpAttempts += attempts
     const u = (json as { usage?: { prompt_tokens?: number; completion_tokens?: number } }).usage
@@ -204,10 +224,31 @@ async function emitAttempt(
   }
   const task: AgenticTask = {
     id: bt.id,
-    systemPrompt: SWE_SEED_PROMPT,
     userPrompt: cfg.promptAppendix ? `${bt.prompt}\n\n${cfg.promptAppendix}` : bt.prompt,
     meta: { instanceId: bt.id },
   }
+  const workerProfile = withBenchProfile(
+    {
+      name: 'swe-structural-worker',
+      harness: 'cli-base',
+      model: { provider: 'zai', default: MODEL, reasoningEffort: 'high' },
+      tools: { list_files: true, read_file: true, edit_file: true },
+    },
+    {
+      systemPrompt: SWE_SEED_PROMPT,
+      maxTokens: MAX_TOKENS,
+      maxTurns: INNER_TURNS,
+      temperature: cfg.temperature,
+    },
+  )
+  const analystProfile = withBenchProfile(
+    {
+      name: 'swe-structural-analyst',
+      harness: 'cli-base',
+      model: { provider: 'zai', default: MODEL, reasoningEffort: 'high' },
+    },
+    { systemPrompt: defaultAnalystInstruction, maxTokens: MAX_TOKENS },
+  )
   let error: string | undefined
   try {
     const r = await runAgentic({
@@ -216,10 +257,8 @@ async function emitAttempt(
       strategy: refine,
       routerBaseUrl: 'zai-direct', // unused: the `complete` transport short-circuits the router
       routerKey: 'zai-direct',
-      model: MODEL,
-      maxTokens: MAX_TOKENS,
-      temperature: cfg.temperature,
-      innerTurns: INNER_TURNS,
+      workerProfile,
+      analystProfile,
       budget: 1,
       complete: makeTransport(cfg.marks, counter),
     })

package/src/tb-container-executor.mts

@@ -5,6 +5,7 @@
  * provided container id and reports the captured process artifact back through the runtime.
  */
 import { spawn } from 'node:child_process'
+import { agentProfileSchema } from '@tangle-network/agent-interface'
 import type {
   Agent,
   AgentProfile,
@@ -17,6 +18,8 @@ import type {
   Runtime,
   Spend,
 } from '../../src/runtime/index'
+import { harnessInvocation, type LocalHarness } from '../../src/mcp/local-harness'
+import { assertExecutableAgentProfile } from '../../src/runtime/supervise/model-policy'
 
 export interface TbExecOutput {
   /** Primary artifact consumed by drivers that read `{ content }`. */
@@ -40,7 +43,8 @@ export interface TbContainerConfig {
   readonly workdir?: string
   readonly shell?: string
   readonly env?: Readonly<Record<string, string>>
-  readonly wrapCommand?: (task: unknown) => string
+  /** Shell setup required inside the existing task container before the canonical invocation. */
+  readonly commandPrefix?: ReadonlyArray<string>
   readonly parseUsage?: ParseUsage
   readonly budgetExempt?: boolean
   readonly dockerBin?: string
@@ -62,7 +66,7 @@ function resolveContainerId(config: TbContainerConfig): string {
   return id.trim()
 }
 
-function taskToCommand(task: unknown): string {
+function taskToPrompt(task: unknown): string {
   if (typeof task === 'string') return task
   if (task && typeof task === 'object') {
     const obj = task as Record<string, unknown>
@@ -73,6 +77,31 @@ function taskToCommand(task: unknown): string {
   return JSON.stringify(task)
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`
+}
+
+function profileCommand(
+  profile: AgentProfile,
+  task: unknown,
+  prefix: ReadonlyArray<string> = [],
+): string {
+  const harness = profile.harness
+  if (harness !== 'claude-code' && harness !== 'codex' && harness !== 'opencode') {
+    throw new Error(
+      `tbContainerExecutor: profile harness ${JSON.stringify(harness)} is not available in the task container`,
+    )
+  }
+  const invocation = harnessInvocation(
+    harness as LocalHarness,
+    profile,
+    taskToPrompt(task),
+    { dangerouslySkipPermissions: true },
+  )
+  const run = [invocation.command, ...invocation.args].map(shellQuote).join(' ')
+  return [...prefix, `exec ${run}`].join('; ')
+}
+
 /**
  * Compose the `docker exec` argv that runs `command` inside `containerId` via `<shell> -c`.
  * Exported so tests can verify the container path without a live Docker daemon.
@@ -113,6 +142,8 @@ export function createTbContainerExecutor(
   config: TbContainerConfig = {},
 ): ExecutorFactory<TbExecOutput> {
   return (_spec: AgentSpec, ctx: ExecutorContext): Executor<TbExecOutput> => {
+    const profile = agentProfileSchema.parse(_spec.profile)
+    assertExecutableAgentProfile(profile, 'tbContainerExecutor')
     const containerId = resolveContainerId(config)
     const dockerBin = config.dockerBin ?? 'docker'
     const metered = config.parseUsage !== undefined
@@ -133,7 +164,7 @@ export function createTbContainerExecutor(
       runtime,
       budgetExempt,
       execute(task, signal): Promise<ExecutorResult<TbExecOutput>> {
-        const command = (config.wrapCommand ?? taskToCommand)(task)
+        const command = profileCommand(profile, task, config.commandPrefix)
         const args = buildTbDockerExecArgs(containerId, command, {
           ...(config.shell ? { shell: config.shell } : {}),
           ...(config.workdir ? { workdir: config.workdir } : {}),
@@ -221,9 +252,10 @@ export function createTbContainerExecutor(
 export function makeTbContainerWorkerAgent(config: TbContainerConfig = {}): MakeWorkerAgent {
   const factory = createTbContainerExecutor(config)
   return (rawProfile) => {
-    const p = (rawProfile ?? {}) as { name?: unknown }
-    const name = typeof p.name === 'string' && p.name.length > 0 ? p.name : 'tb-worker'
-    const spec: AgentSpec = { profile: rawProfile as AgentProfile, harness: null }
+    const profile = agentProfileSchema.parse(rawProfile)
+    assertExecutableAgentProfile(profile, 'tbContainerWorkerAgent')
+    const name = profile.name ?? 'tb-worker'
+    const spec: AgentSpec = { profile, harness: null }
     const ctx: ExecutorContext = { signal: new AbortController().signal, seams: {} }
     const executor = factory(spec, ctx)
     return { name, act: async () => '', executorSpec: { ...spec, executor } } as Agent<

package/src/tb-container-executor.test.mts

@@ -14,7 +14,14 @@ import {
   type TbExecOutput,
 } from './tb-container-executor.mts'
 
-const spec: AgentSpec = { profile: { name: 'tb-test-worker' }, harness: null }
+const spec: AgentSpec = {
+  profile: {
+    name: 'tb-test-worker',
+    harness: 'opencode',
+    model: { provider: 'tangle-router', default: 'deepseek-v4-flash' },
+  },
+  harness: null,
+}
 
 function context(): ExecutorContext {
   return { signal: new AbortController().signal, seams: {} }
@@ -78,10 +85,11 @@ printf 'argv:%s\\n' "$*"
   assert.equal(metered.budgetExempt, false, 'usage parser makes the executor metered')
   const meteredResult = await executeOneShot(metered, { command: 'echo hello' })
   assert.equal(meteredResult.out.containerId, 'cid')
-  assert.equal(meteredResult.out.command, 'echo hello')
+  assert.match(meteredResult.out.command, /'echo hello'/)
+  assert.match(meteredResult.out.command, /'tangle-router\/deepseek-v4-flash'/)
   assert.match(
     meteredResult.out.stdout,
-    /argv:exec -i --workdir \/work -e OPENAI_BASE_URL=http:\/\/router\.test cid \/bin\/sh -c echo hello/,
+    /argv:exec -i --workdir \/work -e OPENAI_BASE_URL=http:\/\/router\.test cid \/bin\/sh -c exec 'opencode' 'run' 'echo hello' '-m' 'tangle-router\/deepseek-v4-flash'/,
   )
   assert.deepEqual(meteredResult.spent.tokens, { input: 7, output: 11 })
   assert.equal(meteredResult.spent.usd, 0.004)

package/src/tb-supervisor-sidecar.mts

@@ -20,7 +20,6 @@ import { makeTbContainerWorkerAgent, type ParseUsage } from './tb-container-exec
 const CONTAINER_ID = (process.env.TB_TARGET_CONTAINER ?? '').trim()
 const ROUTER_KEY = process.env.OPENAI_API_KEY ?? ''
 const ROUTER_BASE = process.env.OPENAI_BASE_URL ?? 'https://router.tangle.tools/v1'
-const WORKER_MODEL = process.env.WORKER_MODEL ?? 'zai-coding-plan/glm-5.2'
 const DOCKER_BRIDGE_GATEWAY = process.env.DOCKER_BRIDGE_GATEWAY ?? '172.17.0.1'
 const PORT_FILE = process.env.TB_SIDECAR_PORT_FILE ?? '.tb-sidecar-port'
 const LOG_FILE = process.env.TB_SIDECAR_LOG ?? '.tb-sidecar-events.jsonl'
@@ -42,30 +41,6 @@ function logEvent(kind: string, payload: unknown): void {
   console.error(`[sidecar] ${kind} ${JSON.stringify(payload).slice(0, 300)}`)
 }
 
-function workerWrapCommand(task: unknown): string {
-  const instr =
-    typeof task === 'string'
-      ? task
-      : task && typeof task === 'object'
-        ? ((): string => {
-            const o = task as Record<string, unknown>
-            for (const k of ['task', 'prompt', 'content', 'command', 'message', 'instruction']) {
-              if (typeof o[k] === 'string') return o[k] as string
-            }
-            return JSON.stringify(task)
-          })()
-        : String(task)
-  const q = `'${instr.replace(/'/g, `'\\''`)}'`
-  return [
-    'export NVM_DIR="${NVM_DIR:-$HOME/.nvm}"',
-    '{ [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; } 2>/dev/null || true',
-    '{ [ -s /root/.nvm/nvm.sh ] && . /root/.nvm/nvm.sh; } 2>/dev/null || true',
-    `export OPENCODE_CONFIG=${WORKER_CONFIG_PATH}`,
-    `cd ${WORKER_WORKDIR} 2>/dev/null || true`,
-    `opencode --model ${WORKER_MODEL} --format json run ${q}`,
-  ].join('; ')
-}
-
 const parseWorkerUsage: ParseUsage = ({ stdout }) => {
   let input = 0
   let output = 0
@@ -115,9 +90,18 @@ async function main(): Promise<void> {
   const makeWorkerAgent = makeTbContainerWorkerAgent({
     containerId: CONTAINER_ID,
     workdir: WORKER_WORKDIR,
-    wrapCommand: workerWrapCommand,
+    commandPrefix: [
+      'export NVM_DIR="${NVM_DIR:-$HOME/.nvm}"',
+      '{ [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; } 2>/dev/null || true',
+      '{ [ -s /root/.nvm/nvm.sh ] && . /root/.nvm/nvm.sh; } 2>/dev/null || true',
+    ],
     parseUsage: parseWorkerUsage,
-    env: { OPENAI_API_KEY: ROUTER_KEY, OPENAI_BASE_URL: ROUTER_BASE, HOME: '/root' },
+    env: {
+      OPENAI_API_KEY: ROUTER_KEY,
+      OPENAI_BASE_URL: ROUTER_BASE,
+      OPENCODE_CONFIG: WORKER_CONFIG_PATH,
+      HOME: '/root',
+    },
     runtime: 'tb-container',
   })
 

package/src/terminal-compare.ts

@@ -7,7 +7,7 @@
  * judge here.
  *
  * Per task:
- *   ROUND 1 (blind) — `tb run --agent opencode` → parse results.json →
+ *   ROUND 1 (blind) — Terminal-Bench runs one exact AgentProfile → parse results.json →
  *                     resolved_1. This IS blind pass@1.
  *   ROUND r (refine, only if blind failed AND rounds>1) — extract a compact
  *                     summary of round 1's commands + terminal state + the
@@ -26,11 +26,12 @@
  */
 
 import { execFile } from 'node:child_process'
-import { mkdir, readFile, readdir, stat } from 'node:fs/promises'
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { homedir } from 'node:os'
+import { agentProfileSchema } from '@tangle-network/agent-interface'
 
 import { appendRunRecord, type AttemptRecord, type RunRecord } from './corpus'
 import { runPool } from './run-pool'
@@ -38,16 +39,36 @@ import { runPool } from './run-pool'
 const BENCH_ROOT = fileURLToPath(new URL('..', import.meta.url))
 const TB = join(BENCH_ROOT, '.venv', 'bin', 'tb')
 const RUNS_DIR = join(BENCH_ROOT, 'runs')
-const REFINE_IMPORT = 'tb_agents.opencode_refine_agent:OpenCodeRefineAgent'
+const PROFILE_AGENT_IMPORT = 'tb_agents.opencode_router_agent:OpenCodeRouterAgent'
 // The durable learning-flywheel corpus (docs/learning-flywheel.md). terminal-bench
 // is bench-orchestrated (tb owns the containers) so it cannot use buildRunRecord,
-// which consumes runLoop Iterations; instead each task's per-round tb artifacts are
+// which consumes runAgentRounds Iterations; instead each task's per-round tb artifacts are
 // folded into one RunRecord here so the corpus is genuinely cross-benchmark
-// (finsearch-loop.ts writes the same store from the runLoop path).
+// (finsearch-loop.ts writes the same store from the runAgentRounds path).
 const CORPUS = process.env.CORPUS ?? join(BENCH_ROOT, 'corpus', 'terminal.jsonl')
 
 const DATASET = process.env.TB_DATASET ?? 'terminal-bench-core==0.1.1'
-const MODEL = process.env.TB_MODEL ?? 'deepseek/deepseek-v4-pro'
+const MODEL = process.env.TB_MODEL ?? 'deepseek-v4-flash'
+const PROVIDER = process.env.TB_PROVIDER ?? 'tangle-router'
+const PROFILE = agentProfileSchema.parse({
+  name: 'terminal-compare-worker',
+  harness: 'opencode',
+  model: { provider: PROVIDER, default: MODEL },
+  prompt: {
+    systemPrompt:
+      'Solve the Terminal-Bench task completely in the provided container and verify the result before finishing.',
+  },
+  permission: {
+    edit: 'allow',
+    bash: 'allow',
+    webfetch: 'allow',
+    read: 'allow',
+    write: 'allow',
+    external_directory: 'allow',
+  },
+})
+const PROFILE_MODEL = MODEL.includes('/') ? MODEL : `${PROVIDER}/${MODEL}`
+const PROFILE_PATH = join(RUNS_DIR, 'terminal-compare.profile.json')
 const ROUNDS = Math.max(1, Number(process.env.ROUNDS ?? 2))
 const CONCURRENCY = Math.max(1, Number(process.env.CONCURRENCY ?? 2))
 // Per-round wall-clock cap (ms). tb itself enforces task timeouts; this is the
@@ -307,8 +328,8 @@ function informativeFailureMode(mode: string | undefined): string | undefined {
 
 /**
  * Build and persist one flywheel RunRecord per task from terminal-compare's own
- * round data — no buildRunRecord (that consumes runLoop Iterations; tb is not
- * runLoop-shaped). condition = 'refine@k' when a refine budget was available,
+ * round data — no buildRunRecord (that consumes runAgentRounds Iterations; tb is not
+ * runAgentRounds-shaped). condition = 'refine@k' when a refine budget was available,
  * 'blind' when only the single blind round can run (ROUNDS===1). Appended once
  * per task; never throws into the run (corpus capture must not fail the bench).
  */
@@ -330,7 +351,7 @@ async function captureRunRecord(
     benchmark: 'terminal-bench',
     instanceId: taskId,
     condition: ROUNDS > 1 ? `refine@${ROUNDS}` : 'blind',
-    model: MODEL,
+    model: PROFILE.model?.default ?? MODEL,
     blindResolved,
     resolved: last ? last.resolved : blindResolved,
     attempts,
@@ -392,7 +413,7 @@ async function runRound(taskId: string, round: number, prior: string): Promise<R
     'run',
     '-d', DATASET,
     '--task-id', taskId,
-    '-m', MODEL,
+    '-m', PROFILE_MODEL,
     '--output-path', RUNS_DIR,
     '--run-id', runId,
     '--n-concurrent', '1',
@@ -404,14 +425,12 @@ async function runRound(taskId: string, round: number, prior: string): Promise<R
   // literals in values. Hex-encode the prior with an 'h' sentinel so it survives
   // the split and is kept as a string; the refine agent decodes it.
   const priorHex = `h${Buffer.from(prior, 'utf8').toString('hex')}`
-  const args =
-    round === 1
-      ? [...baseArgs, '--agent', 'opencode']
-      : [
-          ...baseArgs,
-          '--agent-import-path', REFINE_IMPORT,
-          '--agent-kwarg', `prior_attempt_hex=${priorHex}`,
-        ]
+  const args = [
+    ...baseArgs,
+    '--agent-import-path', PROFILE_AGENT_IMPORT,
+    '--agent-kwarg', `profile_path=${PROFILE_PATH}`,
+    ...(round > 1 ? ['--agent-kwarg', `prior_attempt_hex=${priorHex}`] : []),
+  ]
   await runTb(args, runId)
   const resolved = await readResolved(outputDir, taskId)
   const trialDir = await findTrialDir(outputDir, taskId)
@@ -457,6 +476,7 @@ async function solveTask(taskId: string): Promise<{
 
 async function main(): Promise<void> {
   await mkdir(RUNS_DIR, { recursive: true })
+  await writeFile(PROFILE_PATH, JSON.stringify(PROFILE, null, 2) + '\n')
   // Validate auth up front — fail loud before spending a single container.
   must('OPENAI_API_KEY')