@tangle-network/agent-bench 0.4.7 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-bench",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "type": "module",
   "description": "Benchmark adapters and execution for agent-runtime across coding, tool-use, RAG, memory, browser, and terminal tasks.",
   "repository": {
@@ -25,11 +25,11 @@
     }
   },
   "dependencies": {
-    "@tangle-network/agent-eval": "0.134.2",
+    "@tangle-network/agent-eval": "0.135.1",
     "@tangle-network/agent-interface": "0.36.0",
-    "@tangle-network/agent-knowledge": "6.1.8",
+    "@tangle-network/agent-knowledge": "6.1.10",
     "@tangle-network/sandbox": "0.15.2",
-    "@tangle-network/agent-runtime": "0.108.1"
+    "@tangle-network/agent-runtime": "0.109.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.5",
@@ -69,11 +69,12 @@
     "run-benchmarks": "tsx src/run-benchmarks-cli.mts",
     "gate-report": "tsx src/corpus-report.mts corpus/finsearch.jsonl",
     "terminal-compare": "tsx src/terminal-compare.ts",
-    "test": "node scripts/run-package-tests.mjs",
+    "test": "node scripts/run-package-tests.mjs && node --test scripts/wait-for-published-dependencies.test.mjs",
     "typecheck:public": "tsc -p tsconfig.public.json",
     "verify:package": "pnpm run verify:package:static && node scripts/verify-packed-consumer.mjs",
     "verify:package:local-runtime": "pnpm run verify:package:static && node scripts/verify-packed-consumer.mjs --local-runtime",
     "verify:package:static": "pnpm run build && publint && attw --pack --profile esm-only .",
+    "wait:published-dependencies": "node scripts/wait-for-published-dependencies.mjs",
     "verify:pier": "tsx scripts/verify-pier-pair.mts"
   }
 }

package/scripts/wait-for-published-dependencies.mjs

@@ -0,0 +1,245 @@
+import { execFile } from 'node:child_process'
+import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+const benchDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const localDependencyProtocol = /^(?:catalog|file|link|patch|portal|workspace):/
+
+export const DEFAULT_TIMEOUT_MS = 20 * 60_000
+export const DEFAULT_INTERVAL_MS = 15_000
+
+export function collectRequiredTangleDependencies(packageJson) {
+  const dependencies = new Map()
+  const sections = [
+    ['dependencies', packageJson.dependencies],
+    ['peerDependencies', packageJson.peerDependencies],
+  ]
+
+  for (const [section, entries] of sections) {
+    for (const [name, spec] of Object.entries(entries ?? {})) {
+      if (!name.startsWith('@tangle-network/')) continue
+      if (
+        section === 'peerDependencies' &&
+        packageJson.peerDependenciesMeta?.[name]?.optional === true
+      ) {
+        continue
+      }
+      if (
+        typeof spec !== 'string' ||
+        spec.length === 0 ||
+        localDependencyProtocol.test(spec)
+      ) {
+        throw new Error(`${packageJson.name} has no published ${name} dependency version`)
+      }
+
+      const previous = dependencies.get(name)
+      if (previous && previous !== spec) {
+        throw new Error(`${packageJson.name} declares conflicting versions for ${name}`)
+      }
+      dependencies.set(name, spec)
+    }
+  }
+
+  return [...dependencies]
+    .map(([name, spec]) => ({ name, spec }))
+    .sort((left, right) => left.name.localeCompare(right.name))
+}
+
+export async function waitForPublishedDependencies(
+  dependencies,
+  {
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    intervalMs = DEFAULT_INTERVAL_MS,
+    probe = probeNpm,
+    sleep = (milliseconds) =>
+      new Promise((resolveSleep) => setTimeout(resolveSleep, milliseconds)),
+    now = Date.now,
+    report = console.log,
+  } = {},
+) {
+  requirePositiveInteger('timeoutMs', timeoutMs)
+  requirePositiveInteger('intervalMs', intervalMs)
+  if (dependencies.length === 0) {
+    throw new Error('agent-bench has no required published @tangle-network dependencies')
+  }
+
+  const startedAt = now()
+  const deadline = startedAt + timeoutMs
+  let attempts = 0
+  let pending = dependencies.map((dependency) => ({ dependency, detail: 'not checked' }))
+
+  report(
+    `Waiting up to ${formatDuration(timeoutMs)} for ${dependencies.length} published dependencies`,
+  )
+
+  while (true) {
+    if (attempts > 0 && now() >= deadline) {
+      throw timeoutError(timeoutMs, attempts, pending)
+    }
+
+    attempts += 1
+    const results = await Promise.all(
+      pending.map(async ({ dependency }) => {
+        try {
+          const result = await probe(dependency, {
+            timeoutMs: Math.max(1, deadline - now()),
+          })
+          return result.available
+            ? undefined
+            : { dependency, detail: result.detail ?? 'not available' }
+        } catch (error) {
+          return {
+            dependency,
+            detail: error instanceof Error ? error.message : String(error),
+          }
+        }
+      }),
+    )
+    pending = results.filter((result) => result !== undefined)
+
+    if (pending.length === 0) {
+      return { attempts, elapsedMs: now() - startedAt }
+    }
+    if (now() >= deadline) {
+      throw timeoutError(timeoutMs, attempts, pending)
+    }
+
+    const delayMs = Math.min(intervalMs, deadline - now())
+    report(
+      `Attempt ${attempts}: ${pending.length}/${dependencies.length} unavailable: ${pending
+        .map(({ dependency }) => `${dependency.name}@${dependency.spec}`)
+        .join(', ')}. Retrying in ${formatDuration(delayMs)}`,
+    )
+    await sleep(delayMs)
+  }
+}
+
+async function probeNpm(dependency, { timeoutMs }) {
+  try {
+    const { stdout } = await execFileAsync(
+      'npm',
+      [
+        'view',
+        `${dependency.name}@${dependency.spec}`,
+        'version',
+        '--json',
+        '--prefer-online',
+      ],
+      {
+        env: { ...process.env, npm_config_color: 'false' },
+        maxBuffer: 1024 * 1024,
+        timeout: Math.min(30_000, timeoutMs),
+      },
+    )
+    const version = JSON.parse(stdout)
+    const available =
+      (typeof version === 'string' && version.length > 0) ||
+      (Array.isArray(version) && version.length > 0)
+    return available
+      ? { available: true }
+      : { available: false, detail: 'npm returned no matching version' }
+  } catch (error) {
+    return { available: false, detail: summarizeCommandError(error) }
+  }
+}
+
+async function readPackedBenchManifest() {
+  const scratch = await mkdtemp(path.join(tmpdir(), 'agent-bench-published-dependencies-'))
+  try {
+    await execFileAsync('pnpm', ['pack', '--pack-destination', scratch], {
+      cwd: benchDir,
+      env: { ...process.env, npm_config_ignore_scripts: 'true' },
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 120_000,
+    })
+    const tarballs = (await readdir(scratch)).filter((name) => name.endsWith('.tgz'))
+    if (tarballs.length !== 1) {
+      throw new Error(`expected one packed agent-bench tarball, found ${tarballs.length}`)
+    }
+    const { stdout } = await execFileAsync(
+      'tar',
+      ['-xOzf', path.join(scratch, tarballs[0]), 'package/package.json'],
+      { maxBuffer: 1024 * 1024, timeout: 30_000 },
+    )
+    return JSON.parse(stdout)
+  } finally {
+    await rm(scratch, { recursive: true, force: true })
+  }
+}
+
+function timeoutError(timeoutMs, attempts, pending) {
+  const details = pending
+    .map(
+      ({ dependency, detail }) =>
+        `- ${dependency.name}@${dependency.spec}: ${firstLine(detail)}`,
+    )
+    .join('\n')
+  return new Error(
+    `Timed out after ${formatDuration(timeoutMs)} and ${attempts} attempts waiting for ${pending.length} published dependencies:\n${details}`,
+  )
+}
+
+function summarizeCommandError(error) {
+  if (!(error instanceof Error)) return String(error)
+  const stderr = typeof error.stderr === 'string' ? error.stderr.trim() : ''
+  return firstLine(stderr || error.message)
+}
+
+function firstLine(value) {
+  return String(value).split(/\r?\n/, 1)[0]
+}
+
+function formatDuration(milliseconds) {
+  if (milliseconds >= 60_000 && milliseconds % 60_000 === 0) {
+    return `${milliseconds / 60_000}m`
+  }
+  if (milliseconds >= 1_000 && milliseconds % 1_000 === 0) {
+    return `${milliseconds / 1_000}s`
+  }
+  return `${milliseconds}ms`
+}
+
+function requirePositiveInteger(name, value) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`)
+  }
+}
+
+function readPositiveInteger(name, fallback) {
+  const value = process.env[name]
+  if (value === undefined) return fallback
+  const parsed = Number(value)
+  requirePositiveInteger(name, parsed)
+  return parsed
+}
+
+async function main() {
+  const packageJson = await readPackedBenchManifest()
+  const dependencies = collectRequiredTangleDependencies(packageJson)
+  const result = await waitForPublishedDependencies(dependencies, {
+    timeoutMs: readPositiveInteger(
+      'BENCH_PUBLISH_WAIT_TIMEOUT_MS',
+      DEFAULT_TIMEOUT_MS,
+    ),
+    intervalMs: readPositiveInteger(
+      'BENCH_PUBLISH_WAIT_INTERVAL_MS',
+      DEFAULT_INTERVAL_MS,
+    ),
+  })
+  console.log(
+    `Published dependencies ready after ${result.attempts} attempt(s) in ${formatDuration(result.elapsedMs)}: ${dependencies
+      .map(({ name, spec }) => `${name}@${spec}`)
+      .join(', ')}`,
+  )
+}
+
+if (path.resolve(process.argv[1] ?? '') === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error))
+    process.exitCode = 1
+  })
+}

package/scripts/wait-for-published-dependencies.test.mjs

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+  collectRequiredTangleDependencies,
+  waitForPublishedDependencies,
+} from './wait-for-published-dependencies.mjs'
+
+test('collects required published Tangle dependencies from a packed manifest', () => {
+  const dependencies = collectRequiredTangleDependencies({
+    name: '@tangle-network/agent-bench',
+    dependencies: {
+      '@tangle-network/agent-runtime': '0.109.0',
+      '@tangle-network/agent-eval': '0.135.1',
+      undici: '^7.0.0',
+    },
+    peerDependencies: {
+      '@tangle-network/agent-interface': '>=0.36.0 <0.37.0',
+      '@tangle-network/optional-peer': '1.0.0',
+    },
+    peerDependenciesMeta: {
+      '@tangle-network/optional-peer': { optional: true },
+    },
+    devDependencies: {
+      '@tangle-network/dev-only': '1.0.0',
+    },
+  })
+
+  assert.deepEqual(dependencies, [
+    { name: '@tangle-network/agent-eval', spec: '0.135.1' },
+    { name: '@tangle-network/agent-interface', spec: '>=0.36.0 <0.37.0' },
+    { name: '@tangle-network/agent-runtime', spec: '0.109.0' },
+  ])
+})
+
+test('retries only unavailable dependencies until all are published', async () => {
+  const dependencies = [
+    { name: '@tangle-network/already-published', spec: '1.0.0' },
+    { name: '@tangle-network/publishes-later', spec: '2.0.0' },
+  ]
+  const calls = new Map()
+  const reports = []
+  let currentTime = 0
+
+  const result = await waitForPublishedDependencies(dependencies, {
+    timeoutMs: 100,
+    intervalMs: 25,
+    now: () => currentTime,
+    sleep: async (milliseconds) => {
+      currentTime += milliseconds
+    },
+    probe: async ({ name }) => {
+      const count = (calls.get(name) ?? 0) + 1
+      calls.set(name, count)
+      return {
+        available: name.endsWith('already-published') || count >= 3,
+        detail: 'not published yet',
+      }
+    },
+    report: (message) => reports.push(message),
+  })
+
+  assert.deepEqual(result, { attempts: 3, elapsedMs: 50 })
+  assert.equal(calls.get('@tangle-network/already-published'), 1)
+  assert.equal(calls.get('@tangle-network/publishes-later'), 3)
+  assert.equal(reports.length, 3)
+})
+
+test('fails at the deadline and names every dependency still missing', async () => {
+  const dependencies = [
+    { name: '@tangle-network/never-published', spec: '9.9.9' },
+    { name: '@tangle-network/also-missing', spec: '8.8.8' },
+  ]
+  let currentTime = 0
+
+  await assert.rejects(
+    waitForPublishedDependencies(dependencies, {
+      timeoutMs: 100,
+      intervalMs: 40,
+      now: () => currentTime,
+      sleep: async (milliseconds) => {
+        currentTime += milliseconds
+      },
+      probe: async () => ({ available: false, detail: 'npm error code E404' }),
+      report: () => {},
+    }),
+    (error) => {
+      assert.match(error.message, /Timed out after 100ms and 3 attempts/)
+      assert.match(error.message, /@tangle-network\/never-published@9\.9\.9/)
+      assert.match(error.message, /@tangle-network\/also-missing@8\.8\.8/)
+      assert.match(error.message, /npm error code E404/)
+      return true
+    },
+  )
+  assert.equal(currentTime, 100)
+})

package/src/aec-gate.mts

@@ -22,7 +22,7 @@ import { resolveAdapter } from './adapters'
 import type { BenchmarkAdapter, BenchTask } from './benchmarks/types'
 import { type AttemptRecord, appendRunRecord, buildRunRecordFromAttempts } from './corpus'
 import { composeStrategies } from './directives'
-import { type RouterConfig, routerChatWithUsage } from '@tangle-network/agent-runtime/loops'
+import { type RouterConfig, routerChatWithUsage } from '@tangle-network/agent-runtime/kernel'
 import { pool } from './stats.mts'
 
 function must(name: string): string {

package/src/benchmarks/agentbench.ts

@@ -9,7 +9,7 @@
 
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/appworld.ts

@@ -22,7 +22,7 @@
 import { spawn } from 'node:child_process'
 import { join } from 'node:path'
 import { createInterface } from 'node:readline'
-import { type OutputAdapter, routerToolLoop, type ToolSpec } from '@tangle-network/agent-runtime/loops'
+import { type OutputAdapter, routerToolLoop, type ToolSpec } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot, preflightVenvImports, runVenvScriptStdin, venvPython } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/bfcl.ts

@@ -11,7 +11,7 @@
 
 import { readFile, stat } from 'node:fs/promises'
 import { join } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/commit0.ts

@@ -23,7 +23,7 @@
 
 import { join } from 'node:path'
 import { readFile } from 'node:fs/promises'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot, preflightVenvImports, runVenvScriptStdin, venvPythonAt } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/dabstep.ts

@@ -11,7 +11,7 @@
 
 import { join } from 'node:path'
 import { access, readFile, stat } from 'node:fs/promises'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot, runVenvPython, runVenvScriptStdin } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/enterpriseops-gym.ts

@@ -30,7 +30,7 @@
 
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot, runVenvScriptStdin } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/programbench.ts

@@ -25,7 +25,7 @@
 
 import { join } from 'node:path'
 import { readFile } from 'node:fs/promises'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot, preflightVenvImports, runVenvScriptStdin } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/rag-shared.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import type { BenchScore, BenchTask, LoadOptions } from './types'
 
 export const FINAL_ANSWER_SENTINEL = 'FINAL ANSWER:'

package/src/benchmarks/swe-bench.ts

@@ -13,7 +13,7 @@
  */
 
 import { join } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import {
   preflightVenvImports,
   readJsonReport,

package/src/benchmarks/tau-bench-shared.ts

@@ -9,7 +9,7 @@
 
 import { readFile, stat } from 'node:fs/promises'
 import { resolve } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { runVenvPython } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/toollm.ts

@@ -9,7 +9,7 @@
 
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/benchmarks/types.ts

@@ -8,7 +8,7 @@
  * from the benchmark's published evaluation harness.
  */
 
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 
 export interface BenchTask {
   /** Stable benchmark instance id. */

package/src/benchmarks/webarena-verified.ts

@@ -9,7 +9,7 @@
 
 import { access, readFile, stat } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
-import type { OutputAdapter } from '@tangle-network/agent-runtime/loops'
+import type { OutputAdapter } from '@tangle-network/agent-runtime/kernel'
 import { benchRoot, runVenvPython } from './_harness'
 import type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'
 

package/src/clbench-codebase-gate.mts

@@ -31,7 +31,7 @@ import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
-import { acquireSandbox } from '@tangle-network/agent-runtime/loops'
+import { acquireSandbox } from '@tangle-network/agent-runtime/kernel'
 import { Sandbox } from '@tangle-network/sandbox'
 import { composeStrategies } from './directives'
 import { type AttemptRecord, appendRunRecord, buildRunRecordFromAttempts } from './corpus'

package/src/clbench-context-gate.mts

@@ -36,7 +36,7 @@ import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { composeStrategies } from './directives'
 import { type AttemptRecord, appendRunRecord, buildRunRecordFromAttempts } from './corpus'
-import { type RouterConfig, routerChatWithUsage } from '@tangle-network/agent-runtime/loops'
+import { type RouterConfig, routerChatWithUsage } from '@tangle-network/agent-runtime/kernel'
 import { selfConsistencySelect, verifierGroundedSelect } from './selector'
 import { type PairedLift, pairedLift, pool } from './stats.mts'
 

package/src/cloud-loop.mts

@@ -30,7 +30,7 @@
  *     env MODEL=gpt-4.1 ROUNDS=3 pnpm exec tsx src/cloud-loop.mts
  */
 import { createChatClient } from '@tangle-network/agent-eval'
-import { observe, openSandboxRun } from '@tangle-network/agent-runtime/loops'
+import { observe, openSandboxRun } from '@tangle-network/agent-runtime/kernel'
 import { Sandbox } from '@tangle-network/sandbox'
 import { answerOutput, sandboxAgentRun } from './sandbox-run'
 

package/src/commit0-env-run.mts

@@ -10,7 +10,7 @@
  */
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { adaptiveRefine, printBenchmarkReport, refine, runBenchmark, sample, type Strategy } from '@tangle-network/agent-runtime/loops'
+import { adaptiveRefine, printBenchmarkReport, refine, runBenchmark, sample, type Strategy } from '@tangle-network/agent-runtime/kernel'
 import { type Commit0Row, createCommit0Environment, rowToTask } from './commit0-env'
 
 function must(name: string): string {

package/src/commit0-env.ts

@@ -20,7 +20,7 @@ import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
-import type { AgenticSurface, AgenticTask, AgenticTool, ArtifactHandle, SurfaceScore } from '@tangle-network/agent-runtime/loops'
+import type { AgenticSurface, AgenticTask, AgenticTool, ArtifactHandle, SurfaceScore } from '@tangle-network/agent-runtime/kernel'
 
 const exec = promisify(execFile)
 

package/src/commit0-gate.mts

@@ -57,7 +57,7 @@ import {
   type Deliverable,
   openSandboxRun,
   type SandboxRun,
-} from '@tangle-network/agent-runtime/loops'
+} from '@tangle-network/agent-runtime/kernel'
 import { Sandbox } from '@tangle-network/sandbox'
 import { createCommit0Adapter } from './benchmarks/commit0'
 import type { BenchTask } from './benchmarks/types'

package/src/corpus.ts

@@ -16,7 +16,7 @@ import { appendFile, mkdir } from 'node:fs/promises'
 import { dirname } from 'node:path'
 import { hashContent, type RunSplitTag, validateRunRecord } from '@tangle-network/agent-eval'
 import type { CorpusRecord } from '@tangle-network/agent-eval/rl'
-import type { Iteration } from '@tangle-network/agent-runtime/loops'
+import type { Iteration } from '@tangle-network/agent-runtime/kernel'
 import type { BenchRuntimeDecisionPoint, BenchRuntimeHookEvent } from './runtime-hook-recorder'
 
 /** One attempt within a condition-run: the prompt/steer sent, the output, the

package/src/examples/lean-proof-gate.mts

@@ -22,7 +22,7 @@ import {
   runBenchmark,
   sample,
   sampleThenRefine,
-} from '@tangle-network/agent-runtime/loops'
+} from '@tangle-network/agent-runtime/kernel'
 import { ensureLeanImage, leanCheck } from './lean-verify.js'
 
 // Real, mathlib-free Lean 4 theorems (compile in core Lean). `header` is everything up to `:=`;

package/src/examples/math-demo.mts

@@ -19,7 +19,7 @@ import {
   runBenchmark,
   sample,
   sampleThenRefine,
-} from '@tangle-network/agent-runtime/loops'
+} from '@tangle-network/agent-runtime/kernel'
 
 // GSM8K-style problems; meta.answer is the ground truth the deployable check compares to.
 const problems: Array<{ q: string; answer: number }> = [

package/src/examples/strategy-demo.mts

@@ -12,7 +12,7 @@
  * Toy task = only a router key needed (no dataset, no sandbox). Run from bench/:
  *   TANGLE_API_KEY=... WORKER_MODEL=gpt-4o-mini tsx src/examples/strategy-demo.mts
  */
-import { adaptiveRefine, type AgenticTask, type ArtifactHandle, defineStrategy, type Environment, printBenchmarkReport, refine, runBenchmark, sample } from '@tangle-network/agent-runtime/loops'
+import { adaptiveRefine, type AgenticTask, type ArtifactHandle, defineStrategy, type Environment, printBenchmarkReport, refine, runBenchmark, sample } from '@tangle-network/agent-runtime/kernel'
 
 // ── 1. Implement an Environment (the only thing a new domain writes) ──────────────
 // A toy: the agent must drive a counter to exactly the target using the increment tool.

package/src/fleet.mts

@@ -13,7 +13,7 @@
  * Run it twice: the second run injects the first run's learnings into the workers.
  */
 import { createChatClient } from '@tangle-network/agent-eval'
-import { FileCorpus, observe, openSandboxRun, renderReport } from '@tangle-network/agent-runtime/loops'
+import { FileCorpus, observe, openSandboxRun, renderReport } from '@tangle-network/agent-runtime/kernel'
 import { Sandbox } from '@tangle-network/sandbox'
 import { answerOutput, sandboxAgentRun, type WorkerBackendType } from './sandbox-run'
 

package/src/gate-cli.mts

@@ -15,7 +15,7 @@
  * single CLI run is the instrument, not the significance test).
  */
 
-import type { AgentProfile } from '@tangle-network/agent-runtime/loops'
+import type { AgentProfile } from '@tangle-network/agent-runtime/kernel'
 import { resolveAdapter } from './adapters'
 import { runGate } from './gate'
 

package/src/gate.test.mts

@@ -19,7 +19,7 @@ import type {
   Executor,
   ExecutorFactory,
   ExecutorResult,
-} from '@tangle-network/agent-runtime/loops'
+} from '@tangle-network/agent-runtime/kernel'
 import type { BenchmarkAdapter, BenchScore, BenchTask } from './benchmarks/types'
 import { runGate, type SolveTask } from './gate'