@tangle-network/agent-eval 0.203.1 → 0.203.4

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/judge-attribution.json

@@ -0,0 +1,140 @@
+{
+  "dispatchRunAttemptId": "e7949644-3d60-4ab9-817e-f80d0a48f5d8",
+  "judgeTags": {
+    "runDir": "/mnt/traces/eval-attempt-artifacts-20261001-r2/after-judge-attribution",
+    "cellId": "attribution:0",
+    "scenarioId": "attribution",
+    "rep": "0",
+    "runAttemptId": "e7949644-3d60-4ab9-817e-f80d0a48f5d8",
+    "attemptNumber": "1"
+  },
+  "report": {
+    "manifestHash": "12b1fd3b28adadf018749116f4680a6105e5c7b5cac8d2af339303fa547fef79",
+    "splitDigest": "sha256:e89df58336656867eafec16cfa0cd7af8564248b98f4aa3e1490c51cc18b5b86",
+    "seed": 42,
+    "reps": 1,
+    "startedAt": "2026-10-01T17:16:26.512Z",
+    "endedAt": "2026-10-01T17:16:26.515Z",
+    "durationMs": 3,
+    "cells": [
+      {
+        "manifestHash": "12b1fd3b28adadf018749116f4680a6105e5c7b5cac8d2af339303fa547fef79",
+        "attempt": {
+          "runAttemptId": "e7949644-3d60-4ab9-817e-f80d0a48f5d8",
+          "number": 1
+        },
+        "cellId": "attribution:0",
+        "scenarioId": "attribution",
+        "rep": 0,
+        "artifact": {
+          "captured": true
+        },
+        "judgeScores": {
+          "operational-attribution": {
+            "dimensions": {
+              "captured": 1
+            },
+            "composite": 1,
+            "notes": "Operational attribution; no research outcome."
+          }
+        },
+        "costUsd": 0,
+        "costProvenance": {
+          "kind": "observed",
+          "usd": 0
+        },
+        "costCallIds": [],
+        "tokenUsage": {
+          "input": 0,
+          "output": 0
+        },
+        "durationMs": 2,
+        "seed": 42,
+        "cached": false
+      }
+    ],
+    "aggregates": {
+      "byJudge": {
+        "operational-attribution": {
+          "mean": 1,
+          "stdev": 0,
+          "ci95": [
+            1,
+            1
+          ],
+          "n": 1,
+          "distribution": {
+            "n": 1,
+            "min": 1,
+            "p50": 1,
+            "p90": 1,
+            "max": 1,
+            "sum": 1
+          }
+        }
+      },
+      "byScenario": {
+        "attribution": {
+          "meanComposite": 1,
+          "ci95": [
+            1,
+            1
+          ],
+          "n": 1,
+          "distribution": {
+            "n": 1,
+            "min": 1,
+            "p50": 1,
+            "p90": 1,
+            "max": 1,
+            "sum": 1
+          }
+        }
+      },
+      "cost": {
+        "totalCalls": 0,
+        "pendingCalls": 0,
+        "unresolvedCalls": 0,
+        "reservedCostUsd": 0,
+        "inputTokens": 0,
+        "outputTokens": 0,
+        "reasoningTokens": 0,
+        "cachedTokens": 0,
+        "cacheWriteTokens": 0,
+        "totalCostUsd": 0,
+        "costProvenance": {
+          "kind": "observed",
+          "usd": 0
+        },
+        "byChannel": [],
+        "unpricedModels": [],
+        "fullyPriced": true,
+        "usageComplete": true,
+        "accountingComplete": true,
+        "incompleteReasons": []
+      },
+      "cellsExecuted": 1,
+      "cellsSkipped": 0,
+      "cellsCached": 0,
+      "cellsFailed": 0,
+      "cellsDispatchFailed": 0,
+      "cellsJudgeFailed": 0,
+      "cellsUnclassifiedFailed": 0
+    },
+    "runDir": "/mnt/traces/eval-attempt-artifacts-20261001-r2/after-judge-attribution",
+    "artifactsByPath": {
+      "attribution:0/attempts/e7949644-3d60-4ab9-817e-f80d0a48f5d8/attempt-1/identity.json": "/mnt/traces/eval-attempt-artifacts-20261001-r2/after-judge-attribution/attribution_0/attempts/e7949644-3d60-4ab9-817e-f80d0a48f5d8/attempt-1/identity.json",
+      "attribution:0/attempts/e7949644-3d60-4ab9-817e-f80d0a48f5d8/attempt-1/artifacts/capture.json": "/mnt/traces/eval-attempt-artifacts-20261001-r2/after-judge-attribution/attribution_0/attempts/e7949644-3d60-4ab9-817e-f80d0a48f5d8/attempt-1/artifacts/capture.json",
+      "attribution:0/attempts/e7949644-3d60-4ab9-817e-f80d0a48f5d8/attempt-1/result.json": "/mnt/traces/eval-attempt-artifacts-20261001-r2/after-judge-attribution/attribution_0/attempts/e7949644-3d60-4ab9-817e-f80d0a48f5d8/attempt-1/result.json"
+    },
+    "scenarios": [
+      {
+        "id": "attribution",
+        "kind": "operational",
+        "scenarioDigest": "sha256:9162e2bc75649b3699e3a3cd56d472ba5013590856802ecdf4b1ce56273eb878"
+      }
+    ]
+  },
+  "providerRequests": 0,
+  "researchUnits": 0
+}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/qualification.log

@@ -0,0 +1 @@
+{"module":{"path":"/home/drew/code/_wt/eval-router-cache-usage-20261001/dist/campaign/index.js","sha256":"2464ee9209cc4d5aa72fb0f64dd8950e0f5d7a3a59bdab5ad3a3148b4db52061"},"retryRetained":true,"resumeRetained":true,"legacyFilesPreserved":4,"pathGuard":"Artifact path must remain inside this execution attempt","optimizationFailedCandidateRecovered":true,"providerRequests":0,"operationalLedgerReceipts":4,"researchUnits":0}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/qualify.mjs

@@ -0,0 +1,165 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, writeFileSync, readdirSync, mkdirSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import assert from 'node:assert/strict'
+
+const root = process.env.PROOF_ROOT
+const modulePath = process.env.EVAL_MODULE
+if (!root || !modulePath) throw new Error('PROOF_ROOT and EVAL_MODULE are required')
+const { runEval, runOptimization } = await import(pathToFileURL(modulePath).href)
+const { CostLedger } = await import(pathToFileURL(process.env.EVAL_COST_MODULE).href)
+const hash = data => createHash('sha256').update(data).digest('hex')
+const json = path => JSON.parse(readFileSync(path, 'utf8'))
+const save = (path, value) => writeFileSync(path, JSON.stringify(value, null, 2) + '\n')
+const scenarios = [{ id: 'capture-retention', kind: 'operational', scenarioDigest: 'sha256:' + hash('attempt-artifact-retention') }]
+const base = { scenarios, reps: 1, seed: 42, expectUsage: 'off', labeledStore: 'off', dispatchRef: 'operational-attempt-retention-v1', maxConcurrency: 1 }
+const interruption = 'Operational interruption after native artifact capture'
+
+async function qualify(mode) {
+  const runDir = join(root, 'after-' + mode)
+  const observed = []
+  let invocations = 0
+  const costLedger = new CostLedger()
+  const opts = { ...base, runDir, costLedger, dispatch: async (_scenario, ctx) => {
+    const invocation = ++invocations
+    const value = { cellId: ctx.cellId, runAttemptId: ctx.runAttemptId, invocation, content: 'Actual filesystem capture from invocation ' + invocation }
+    ctx.trace.span('native.callback.capture', { invocation, runAttemptId: ctx.runAttemptId }).end()
+    const path = await ctx.artifacts.writeJson('captured-response.json', value)
+    observed.push({ invocation, path, sha256: hash(readFileSync(path)), value })
+    const metered = await ctx.cost.runPaidCall({
+      actor: 'operational-file-read',
+      execute: async () => readFileSync(path, 'utf8'),
+      receipt: () => ({ model: 'not-an-inference', inputTokens: 0, outputTokens: 0, estimatedCostUsd: 0 }),
+    })
+    assert.equal(metered.succeeded, true)
+    if (invocation === 1) throw new Error(interruption)
+    return value
+  }}
+  const reports = []
+  if (mode === 'retry') reports.push(await runEval({ ...opts, cellRetry: { attempts: 2, retryable: f => f.error.message === interruption } }))
+  else {
+    reports.push(await runEval(opts))
+    reports.push(await runEval(opts))
+  }
+  assert.equal(invocations, 2)
+  assert.notEqual(observed[0].path, observed[1].path)
+  const attempts = observed.map(item => {
+    assert.equal(hash(readFileSync(item.path)), item.sha256)
+    const attemptDir = dirname(dirname(item.path))
+    const identity = json(join(attemptDir, 'identity.json'))
+    const result = json(join(attemptDir, 'result.json'))
+    const trace = readFileSync(join(attemptDir, 'trace/spans.jsonl'), 'utf8').split('\n').filter(Boolean).map(JSON.parse)
+    assert.equal(identity.runAttemptId, item.value.runAttemptId)
+    assert.deepEqual(result.attempt, { runAttemptId: identity.runAttemptId, number: identity.number })
+    assert.equal(identity.cellId, item.value.cellId)
+    assert.equal(identity.manifestHash, result.manifestHash)
+    assert.equal(trace[0].invocation, item.invocation)
+    return { identity, result, trace, path: relative(root, attemptDir) }
+  })
+  const cellDir = dirname(dirname(dirname(dirname(dirname(observed[1].path)))))
+  const pointer = json(join(cellDir, 'latest-attempt.json'))
+  assert.deepEqual(pointer, reports.at(-1).cells[0].attempt)
+  assert.equal(attempts[0].identity.number, 1)
+  assert.equal(attempts[1].identity.number, mode === 'retry' ? 2 : 1)
+  assert.equal(attempts[0].identity.runAttemptId === attempts[1].identity.runAttemptId, mode === 'retry')
+  const receipt = json(join(root, attempts[0].path, 'failure-receipt.json'))
+  assert.equal(receipt.failure.error.message, interruption)
+  assert.deepEqual(receipt.cell.attempt, attempts[0].result.attempt)
+  const reused = await runEval(opts)
+  assert.equal(invocations, 2)
+  assert.equal(reused.cells[0].cached, true)
+  assert.deepEqual(reused.cells[0].attempt, pointer)
+  const ledgerReceipts = costLedger.list()
+  assert.equal(ledgerReceipts.length, 2)
+  ledgerReceipts.forEach((call, index) => {
+    assert.equal(call.tags.runAttemptId, attempts[index].identity.runAttemptId)
+    assert.equal(call.tags.attemptNumber, String(attempts[index].identity.number))
+  })
+  assert.equal(reports.at(-1).cells[0].costCallIds.length, mode === 'retry' ? 2 : 1)
+  const result = { invocations, observed, attempts, receipt, pointer, reports, ledgerReceipts, cacheReuse: reused, firstContentStillPresent: true, modelInference: false, researchUnits: 0 }
+  save(join(runDir, 'observation.json'), result)
+  return result
+}
+
+const summary = { module: { path: modulePath, sha256: hash(readFileSync(modulePath)) }, retry: await qualify('retry'), resume: await qualify('resume') }
+
+// Use a copied historical cell to prove new execution never writes its legacy capture paths.
+const legacyRun = join(root, 'after-legacy')
+const legacyCell = join(legacyRun, 'capture-retention_0')
+mkdirSync(legacyCell, { recursive: true })
+const originalCell = join(process.env.BASELINE_ROOT, 'before-resume/capture-retention_0')
+const legacySnapshot = {}
+for (const name of readdirSync(originalCell)) {
+  const bytes = readFileSync(join(originalCell, name))
+  writeFileSync(join(legacyCell, name), bytes)
+  legacySnapshot[name] = hash(bytes)
+}
+const legacyReport = await runEval({ ...base, runDir: legacyRun, resumable: false, dispatch: async (_scenario, ctx) => {
+  await ctx.artifacts.writeJson('captured-response.json', { continuation: true, runAttemptId: ctx.runAttemptId })
+  ctx.trace.span('legacy.continuation').end()
+  return { continuation: true }
+}})
+for (const [name, sha] of Object.entries(legacySnapshot)) assert.equal(hash(readFileSync(join(legacyCell, name))), sha)
+summary.legacy = { originalCell, legacySnapshot, report: legacyReport, allHistoricalCellFilesUnchanged: true }
+
+// Exercise the public artifact scope while a real attempt identity exists.
+const guardRun = join(root, 'after-path-guard')
+let guard
+const guardReport = await runEval({ ...base, runDir: guardRun, dispatch: async (_scenario, ctx) => {
+  const own = await ctx.artifacts.writeJson('capture.json', { own: true })
+  const identityPath = join(dirname(dirname(own)), 'identity.json')
+  const before = hash(readFileSync(identityPath))
+  let rejection
+  try { await ctx.artifacts.writeJson('../identity.json', { overwritten: true }) }
+  catch (error) { rejection = error.message }
+  const after = hash(readFileSync(identityPath))
+  assert.equal(rejection, 'Artifact path must remain inside this execution attempt')
+  assert.equal(before, after)
+  guard = { rejection, identityBefore: before, identityAfter: after }
+  return guard
+}})
+summary.pathGuard = { ...guard, report: guardReport }
+
+// Interrupt after a failed candidate settles. Reopen the native search ledger,
+// then observe its prior candidate through runOptimization's stored-cell reader.
+const optimizationDir = join(root, 'after-optimization')
+let proposals = 0
+const histories = []
+const optimizationOpts = {
+  ...base, runDir: optimizationDir,
+  judges: [{ name: 'operational-quality', dimensions: [{ key: 'captured', description: 'Artifact was returned' }], judgeVersion: 'operational-v1', score: () => ({ dimensions: { captured: 1 }, composite: 1, notes: 'Operational artifact only; no research outcome.' }) }],
+  baselineSurface: 'baseline', populationSize: 1, maxGenerations: 2,
+  dispatchWithSurface: async (surface, _scenario, ctx) => {
+    await ctx.artifacts.writeJson('captured-response.json', { surface, runAttemptId: ctx.runAttemptId })
+    ctx.trace.span('native.optimization.capture', { surface }).end()
+    if (surface === 'failed-candidate') throw new Error('Operational candidate interruption')
+    return { surface }
+  },
+  proposer: {
+    kind: 'operational-retention-qualification',
+    async propose(ctx) {
+      proposals++
+      histories.push({ proposal: proposals, history: ctx.history })
+      if (proposals === 1) return ['failed-candidate']
+      if (proposals === 2) throw new Error('Operational stop after candidate settlement')
+      return ['resumed-candidate']
+    },
+  },
+}
+let firstError
+try { await runOptimization(optimizationOpts) }
+catch (error) { firstError = error.message }
+save(join(optimizationDir, 'first-interruption.json'), { firstError, proposals, histories })
+assert.match(firstError ?? '', /Operational stop after candidate settlement/)
+const optimized = await runOptimization(optimizationOpts)
+const resumedHistory = histories.find(h => h.proposal === 3)?.history
+assert.ok(resumedHistory)
+const failed = resumedHistory.flatMap(g => g.candidates).find(c => c.coverage?.unscorableCells?.length)
+assert.ok(failed, 'Reopened optimization must retain its failed candidate')
+assert.equal(failed.coverage.expectedCells, 1)
+assert.equal(failed.coverage.scorableCells, 0)
+assert.match(JSON.stringify(failed.coverage.unscorableCells), /Operational candidate interruption/)
+summary.optimization = { firstError, proposals, histories, failedCandidateRecovered: true, optimized }
+save(join(root, 'after-summary.json'), summary)
+console.log(JSON.stringify({ module: summary.module, retryRetained: summary.retry.firstContentStillPresent, resumeRetained: summary.resume.firstContentStillPresent, legacyFilesPreserved: Object.keys(legacySnapshot).length, pathGuard: guard.rejection, optimizationFailedCandidateRecovered: true, providerRequests: 0, operationalLedgerReceipts: 4, researchUnits: 0 }))

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduce.mjs

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+const { runEval } = await import(pathToFileURL(process.env.EVAL_MODULE).href)
+const root = process.env.PROOF_ROOT
+const hash = bytes => createHash('sha256').update(bytes).digest('hex')
+const save = (path, value) => writeFileSync(path, JSON.stringify(value, null, 2) + '\n')
+const result = { module: { path: process.env.EVAL_MODULE, sha256: hash(readFileSync(process.env.EVAL_MODULE)) }, providerRequests: 0, researchUnits: 0 }
+for (const mode of ['retry', 'resume']) {
+  const runDir = join(root, 'reproduction-' + mode)
+  let invocations = 0
+  const observed = []
+  let firstTrace
+  const opts = {
+    runDir, scenarios: [{ id: 'capture-retention', kind: 'operational' }], reps: 1, seed: 42,
+    expectUsage: 'off', labeledStore: 'off', dispatchRef: 'operational-attempt-retention-baseline-v1', maxConcurrency: 1,
+    dispatch: async (_scenario, ctx) => {
+      const invocation = ++invocations
+      const value = { cellId: ctx.cellId, runAttemptId: ctx.runAttemptId, invocation }
+      const path = await ctx.artifacts.writeJson('captured-response.json', value)
+      const tracePath = join(dirname(path), 'spans.jsonl')
+      if (invocation === 2 && existsSync(tracePath)) firstTrace = { path: tracePath, bytes: readFileSync(tracePath, 'utf8'), sha256: hash(readFileSync(tracePath)) }
+      ctx.trace.span('native.callback.capture', { invocation, runAttemptId: ctx.runAttemptId }).end()
+      observed.push({ path, value, sha256: hash(readFileSync(path)) })
+      save(join(runDir, 'observer-retained-captures.json'), observed)
+      if (invocation === 1) throw new Error('Operational interruption after native artifact capture')
+      return value
+    },
+  }
+  const reports = mode === 'retry'
+    ? [await runEval({ ...opts, cellRetry: { attempts: 2, retryable: () => true } })]
+    : [await runEval(opts), await runEval(opts)]
+  const firstContentStillPresent = hash(readFileSync(observed[0].path)) === observed[0].sha256
+  const firstTraceStillPresent = firstTrace ? hash(readFileSync(firstTrace.path)) === firstTrace.sha256 : null
+  result[mode] = { invocations, observed, reports, firstTrace, firstContentStillPresent, firstTraceStillPresent, finalTrace: readFileSync(join(dirname(observed[1].path), 'spans.jsonl'), 'utf8') }
+}
+save(join(root, 'reproduction-summary.json'), result)
+console.log(JSON.stringify({ module: result.module, retry: { artifactRetained: result.retry.firstContentStillPresent, traceRetained: result.retry.firstTraceStillPresent }, resume: { artifactRetained: result.resume.firstContentStillPresent, traceRetained: result.resume.firstTraceStillPresent }, providerRequests: 0, researchUnits: 0 }))

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-resume/capture-retention_0/cached-result.json

@@ -0,0 +1 @@
+{"manifestHash":"28689623eb0a94107e244d8f418b5e00046bc193557ebdc02902197c9910d5ae","cellId":"capture-retention:0","scenarioId":"capture-retention","rep":0,"artifact":{"cellId":"capture-retention:0","runAttemptId":"d9803cca-2f1c-4310-92d5-625ace4f019b","invocation":2},"judgeScores":{},"costUsd":0,"costProvenance":{"kind":"observed","usd":0},"costCallIds":[],"tokenUsage":{"input":0,"output":0},"durationMs":1,"seed":42,"cached":false}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-resume/capture-retention_0/captured-response.json

@@ -0,0 +1,5 @@
+{
+  "cellId": "capture-retention:0",
+  "runAttemptId": "d9803cca-2f1c-4310-92d5-625ace4f019b",
+  "invocation": 2
+}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-resume/capture-retention_0/failure-receipt.json

@@ -0,0 +1,58 @@
+{
+  "schemaVersion": 1,
+  "runAttemptId": "5da9ca02-da7a-41f4-a05b-fc8d6fe6b340",
+  "recordedAt": "2026-10-01T17:15:23.736Z",
+  "failure": {
+    "stage": "dispatch",
+    "error": {
+      "name": "Error",
+      "message": "Operational interruption after native artifact capture",
+      "stack": "Error: Operational interruption after native artifact capture\n    at Object.dispatch (file:///mnt/traces/eval-attempt-artifacts-20261001-r2/reproduce.mjs:27:35)\n    at async executeCell (file:///home/drew/webb/_wt/lab-evidence-unified/node_modules/.pnpm/@tangle-network+agent-eval@0.203.0/node_modules/@tangle-network/agent-eval/dist/llm-judge-C-0P1WiT.js:459:19)\n    at async file:///home/drew/webb/_wt/lab-evidence-unified/node_modules/.pnpm/@tangle-network+agent-eval@0.203.0/node_modules/@tangle-network/agent-eval/dist/llm-judge-C-0P1WiT.js:888:15\n    at async Promise.allSettled (index 0)\n    at async runCampaign (file:///home/drew/webb/_wt/lab-evidence-unified/node_modules/.pnpm/@tangle-network+agent-eval@0.203.0/node_modules/@tangle-network/agent-eval/dist/llm-judge-C-0P1WiT.js:935:22)\n    at async file:///mnt/traces/eval-attempt-artifacts-20261001-r2/reproduce.mjs:33:8"
+    }
+  },
+  "cell": {
+    "manifestHash": "28689623eb0a94107e244d8f418b5e00046bc193557ebdc02902197c9910d5ae",
+    "cellId": "capture-retention:0",
+    "scenarioId": "capture-retention",
+    "rep": 0,
+    "artifact": null,
+    "judgeScores": {},
+    "costUsd": 0,
+    "costProvenance": {
+      "kind": "observed",
+      "usd": 0
+    },
+    "costCallIds": [],
+    "tokenUsage": {
+      "input": 0,
+      "output": 0
+    },
+    "durationMs": 0,
+    "seed": 42,
+    "cached": false,
+    "errorStage": "dispatch",
+    "error": "Operational interruption after native artifact capture"
+  },
+  "cost": {
+    "totalCalls": 0,
+    "pendingCalls": 0,
+    "unresolvedCalls": 0,
+    "reservedCostUsd": 0,
+    "inputTokens": 0,
+    "outputTokens": 0,
+    "reasoningTokens": 0,
+    "cachedTokens": 0,
+    "cacheWriteTokens": 0,
+    "totalCostUsd": 0,
+    "costProvenance": {
+      "kind": "observed",
+      "usd": 0
+    },
+    "byChannel": [],
+    "unpricedModels": [],
+    "fullyPriced": true,
+    "usageComplete": true,
+    "accountingComplete": true,
+    "incompleteReasons": []
+  }
+}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-resume/capture-retention_0/spans.jsonl

@@ -0,0 +1 @@
+{"name":"native.callback.capture","cellId":"capture-retention:0","startMs":1790874923736,"invocation":2,"runAttemptId":"d9803cca-2f1c-4310-92d5-625ace4f019b","durationMs":0}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-resume/observer-retained-captures.json

@@ -0,0 +1,20 @@
+[
+  {
+    "path": "/mnt/traces/eval-attempt-artifacts-20261001-r2/reproduction-resume/capture-retention_0/captured-response.json",
+    "value": {
+      "cellId": "capture-retention:0",
+      "runAttemptId": "5da9ca02-da7a-41f4-a05b-fc8d6fe6b340",
+      "invocation": 1
+    },
+    "sha256": "56e04e8091749fee3ddae2a3456baebf72c19ac8ce374f92d07fd2d3d9350d2a"
+  },
+  {
+    "path": "/mnt/traces/eval-attempt-artifacts-20261001-r2/reproduction-resume/capture-retention_0/captured-response.json",
+    "value": {
+      "cellId": "capture-retention:0",
+      "runAttemptId": "d9803cca-2f1c-4310-92d5-625ace4f019b",
+      "invocation": 2
+    },
+    "sha256": "da33ee06d5bb8043c1e571e72cdd7bbb9b6cc8ea9a2b456c9473fb59e937da8c"
+  }
+]

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-retry/capture-retention_0/cached-result.json

@@ -0,0 +1 @@
+{"manifestHash":"28689623eb0a94107e244d8f418b5e00046bc193557ebdc02902197c9910d5ae","cellId":"capture-retention:0","scenarioId":"capture-retention","rep":0,"artifact":{"cellId":"capture-retention:0","runAttemptId":"928ae03a-a64d-4d2a-bb41-0b54ed5fa7d7","invocation":2},"judgeScores":{},"costUsd":0,"costProvenance":{"kind":"observed","usd":0},"costCallIds":[],"tokenUsage":{"input":0,"output":0},"durationMs":0,"seed":42,"cached":false,"retryAttempts":1}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-retry/capture-retention_0/captured-response.json

@@ -0,0 +1,5 @@
+{
+  "cellId": "capture-retention:0",
+  "runAttemptId": "928ae03a-a64d-4d2a-bb41-0b54ed5fa7d7",
+  "invocation": 2
+}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-retry/capture-retention_0/failure-receipt.attempt-1.json

@@ -0,0 +1,58 @@
+{
+  "schemaVersion": 1,
+  "runAttemptId": "928ae03a-a64d-4d2a-bb41-0b54ed5fa7d7",
+  "recordedAt": "2026-10-01T17:15:23.734Z",
+  "failure": {
+    "stage": "dispatch",
+    "error": {
+      "name": "Error",
+      "message": "Operational interruption after native artifact capture",
+      "stack": "Error: Operational interruption after native artifact capture\n    at Object.dispatch (file:///mnt/traces/eval-attempt-artifacts-20261001-r2/reproduce.mjs:27:35)\n    at async executeCell (file:///home/drew/webb/_wt/lab-evidence-unified/node_modules/.pnpm/@tangle-network+agent-eval@0.203.0/node_modules/@tangle-network/agent-eval/dist/llm-judge-C-0P1WiT.js:459:19)\n    at async file:///home/drew/webb/_wt/lab-evidence-unified/node_modules/.pnpm/@tangle-network+agent-eval@0.203.0/node_modules/@tangle-network/agent-eval/dist/llm-judge-C-0P1WiT.js:888:15\n    at async Promise.allSettled (index 0)\n    at async runCampaign (file:///home/drew/webb/_wt/lab-evidence-unified/node_modules/.pnpm/@tangle-network+agent-eval@0.203.0/node_modules/@tangle-network/agent-eval/dist/llm-judge-C-0P1WiT.js:935:22)\n    at async file:///mnt/traces/eval-attempt-artifacts-20261001-r2/reproduce.mjs:32:8"
+    }
+  },
+  "cell": {
+    "manifestHash": "28689623eb0a94107e244d8f418b5e00046bc193557ebdc02902197c9910d5ae",
+    "cellId": "capture-retention:0",
+    "scenarioId": "capture-retention",
+    "rep": 0,
+    "artifact": null,
+    "judgeScores": {},
+    "costUsd": 0,
+    "costProvenance": {
+      "kind": "observed",
+      "usd": 0
+    },
+    "costCallIds": [],
+    "tokenUsage": {
+      "input": 0,
+      "output": 0
+    },
+    "durationMs": 1,
+    "seed": 42,
+    "cached": false,
+    "errorStage": "dispatch",
+    "error": "Operational interruption after native artifact capture"
+  },
+  "cost": {
+    "totalCalls": 0,
+    "pendingCalls": 0,
+    "unresolvedCalls": 0,
+    "reservedCostUsd": 0,
+    "inputTokens": 0,
+    "outputTokens": 0,
+    "reasoningTokens": 0,
+    "cachedTokens": 0,
+    "cacheWriteTokens": 0,
+    "totalCostUsd": 0,
+    "costProvenance": {
+      "kind": "observed",
+      "usd": 0
+    },
+    "byChannel": [],
+    "unpricedModels": [],
+    "fullyPriced": true,
+    "usageComplete": true,
+    "accountingComplete": true,
+    "incompleteReasons": []
+  }
+}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-retry/capture-retention_0/spans.jsonl

@@ -0,0 +1 @@
+{"name":"native.callback.capture","cellId":"capture-retention:0","startMs":1790874923735,"invocation":2,"runAttemptId":"928ae03a-a64d-4d2a-bb41-0b54ed5fa7d7","durationMs":0}

package/docs/proofs/campaign-attempt-retention-20261001/artifacts/current/reproduction-retry/observer-retained-captures.json

@@ -0,0 +1,20 @@
+[
+  {
+    "path": "/mnt/traces/eval-attempt-artifacts-20261001-r2/reproduction-retry/capture-retention_0/captured-response.json",
+    "value": {
+      "cellId": "capture-retention:0",
+      "runAttemptId": "928ae03a-a64d-4d2a-bb41-0b54ed5fa7d7",
+      "invocation": 1
+    },
+    "sha256": "eb737cc9d581881831f4f0092b590c11a3435a0ced7b689f8d987072140057d0"
+  },
+  {
+    "path": "/mnt/traces/eval-attempt-artifacts-20261001-r2/reproduction-retry/capture-retention_0/captured-response.json",
+    "value": {
+      "cellId": "capture-retention:0",
+      "runAttemptId": "928ae03a-a64d-4d2a-bb41-0b54ed5fa7d7",
+      "invocation": 2
+    },
+    "sha256": "e28d164f092d29a9e3259ec255efa7b0a6fc42f5148373d314ec5e26b29bdf3e"
+  }
+]