threadwire 0.1.21 → 0.1.23

package/src/evidence-store.js

@@ -2,10 +2,23 @@
 
 import {createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, timingSafeEqual} from "node:crypto"
 import {spawnSync} from "node:child_process"
-import {constants as fsConstants} from "node:fs"
+import {constants as fsConstants, unlinkSync} from "node:fs"
 import {mkdir, open, readdir, rename, unlink} from "node:fs/promises"
 import {basename, isAbsolute, join, parse, relative} from "node:path"
 import {StringDecoder} from "node:string_decoder"
+import {applyRedactionRanges, redactionRanges, redactText} from "./redaction.js"
+import {
+  isIndexJournalName,
+  isPendingIndexName,
+  isReadyIndexName,
+  readyIndexRunHash,
+  runHash,
+  RunIndex,
+  validateInspectRequest,
+  inspectIndex
+} from "./evidence-index.js"
+
+export {redactText}
 
 const HANDLE_PATTERN = /^evidence_([A-Za-z0-9_-]{43})$/u
 const META_SUFFIX = ".meta.json"
@@ -92,6 +105,12 @@ export class EvidenceStore {
     this.maintenance = Promise.resolve()
     /** @type {Map<string, {bytes: number, events: number}>} */
     this.runs = new Map()
+    /** @type {Map<string, RunIndex>} */
+    this.runIndices = new Map()
+    /** @type {Map<string, number>} */
+    this.runArtifactCounts = new Map()
+    /** @type {Map<string, number>} */
+    this.runIndexBytes = new Map()
   }
 
   /**
@@ -150,6 +169,9 @@ export class EvidenceStore {
   async finishClose() {
     await this.maintenance
     if (this.activeOperations > 0) await new Promise((resolve) => this.operationWaiters.push(() => resolve(undefined)))
+    for (const index of this.runIndices.values()) {
+      if (!index.finalized) await index.abort().catch(() => {})
+    }
     await this.assertPinnedRoot()
     await this.lease.close()
     this.closed = true
@@ -214,6 +236,8 @@ export class EvidenceStore {
     // JavaScript runs through here without yielding: reserve the slot before
     // the first await so concurrent creations observe this pending artifact.
     this.artifactSlots += 1
+    const runId = metadata.owner.runId
+    this.runArtifactCounts.set(runId, (this.runArtifactCounts.get(runId) ?? 0) + 1)
     /** @type {import("node:fs/promises").FileHandle | undefined} */
     let file
     try {
@@ -227,6 +251,7 @@ export class EvidenceStore {
       await safeUnlink(this.path(id, META_SUFFIX))
       this.reserve(metadata.owner.runId, -overheadBytes, 0)
       this.artifactSlots -= 1
+      this.decrementRunArtifactCount(metadata.owner.runId)
       finishOperation()
       throw error
     }
@@ -321,6 +346,100 @@ export class EvidenceStore {
     }
   }
 
+  /**
+   * @param {object} owner
+   * @param {{provider?: string}} [options]
+   * @returns {RunIndex}
+   */
+  ensureRunIndex(owner, options = {}) {
+    this.assertScope(owner)
+    if (this.closed || this.closing) throw new Error("Evidence store is closed")
+    const runId = /** @type {{runId: string}} */ (owner).runId
+    let index = this.runIndices.get(runId)
+    if (index) {
+      if (options.provider && !index.provider) index.provider = options.provider
+      return index
+    }
+    const initialBytes = this.runIndexBytes.get(runId) ?? 0
+    index = new RunIndex(this, owner, options, initialBytes)
+    this.runIndices.set(runId, index)
+    return index
+  }
+
+  /** @param {object} owner @param {string[]} redactions */
+  setRunIndexRedactions(owner, redactions) {
+    this.assertScope(owner)
+    if (this.closed || this.closing) throw new Error("Evidence store is closed")
+    const index = this.ensureRunIndex(owner, {})
+    index.setRedactions([...this.runtimeRedactions, ...validateRedactions(redactions)])
+  }
+
+  /** @param {object} owner @param {import("./evidence-index.js").EvidenceIndexEvent} event */
+  async recordEvent(owner, event) {
+    this.assertScope(owner)
+    if (this.closed || this.closing) throw new Error("Evidence store is closed")
+    const index = this.ensureRunIndex(owner, event.provider ? {provider: event.provider} : {})
+    await index.recordEvent(event)
+  }
+
+  /** @param {object} owner @param {{state: "completed" | "failed", exitCode: number}} terminal */
+  async finalizeRunIndex(owner, terminal) {
+    this.assertScope(owner)
+    if (this.closed || this.closing) throw new Error("Evidence store is closed")
+    const index = this.runIndices.get(/** @type {{runId: string}} */ (owner).runId)
+    if (index) await index.finalize(terminal)
+  }
+
+  /** @param {object} owner @param {unknown} request @returns {Promise<import("./evidence-index.js").EvidenceInspectResult>} */
+  async inspect(owner, request) {
+    this.assertScope(owner)
+    const validated = validateInspectRequest(request)
+    const finishOperation = this.beginOperation()
+    try {
+      return await this.inspectLocked(owner, validated)
+    } finally {
+      finishOperation()
+    }
+  }
+
+  /** @param {object} owner @param {import("./evidence-index.js").EvidenceInspectRequest} validated */
+  async inspectLocked(owner, validated) {
+    const id = this.lookupCapability(validated.handle)
+    if (!id) throw new EvidenceAccessError()
+    const metadata = this.artifacts.get(id)
+    if (!metadata || metadata.state !== "ready" || metadata.expiresAt <= this.clock() || !sameOwner(metadata.owner, owner)) {
+      throw new EvidenceAccessError()
+    }
+    const indexPath = this.path(runHash(metadata.owner.runId), ".index")
+    const indexStats = await safeRegularFile(indexPath)
+    if (indexStats === null) throw new EvidenceAccessError()
+    try {
+      return inspectIndex(indexPath, validated, this)
+    } catch (error) {
+      if (error instanceof EvidenceAccessError) throw error
+      if (error instanceof Error && (error.name === "EvidenceAccessError" || /unavailable/u.test(error.message))) {
+        throw new EvidenceAccessError()
+      }
+      throw error
+    }
+  }
+
+  /** @param {unknown} request @returns {Promise<import("./evidence-index.js").EvidenceInspectResult>} */
+  async inspectBearer(request) {
+    const validated = validateInspectRequest(request)
+    const id = this.lookupCapability(validated.handle)
+    if (!id) throw new EvidenceAccessError()
+    const metadata = this.artifacts.get(id)
+    if (!metadata) throw new EvidenceAccessError()
+    const owner = Object.freeze({...metadata.owner})
+    this.scopes.add(owner)
+    try {
+      return await this.inspect(owner, validated)
+    } finally {
+      this.scopes.delete(owner)
+    }
+  }
+
   /** @param {object} owner @param {string} handle @param {"delivery_succeeded" | "delivery_failed"} state */
   recordDelivery(owner, handle, state) {
     const finish = this.beginOperation()
@@ -440,6 +559,7 @@ export class EvidenceStore {
     const names = await readdir(this.root)
     const candidates = new Map()
     const abandonedTemps = []
+    const readyIndexNames = []
     for (const name of names) {
       const match = /^([A-Za-z0-9_-]{43})(\.meta\.json|\.payload|\.pending)$/u.exec(name)
       if (name === LOCK_FILE || name === ROOT_MARKER) continue
@@ -447,6 +567,14 @@ export class EvidenceStore {
         abandonedTemps.push(name)
         continue
       }
+      if (isPendingIndexName(name) || isIndexJournalName(name)) {
+        abandonedTemps.push(name)
+        continue
+      }
+      if (isReadyIndexName(name)) {
+        readyIndexNames.push(name)
+        continue
+      }
       if (!match) {
         throw new Error("Evidence store contains an unknown entry")
       }
@@ -458,6 +586,8 @@ export class EvidenceStore {
       candidates.set(id, group)
     }
     for (const name of abandonedTemps) await safeUnlink(join(this.root, basename(name)))
+    /** @type {Map<string, string>} */
+    const validRunHashes = new Map()
     for (const [id, files] of candidates) {
       let metadata
       try {
@@ -474,10 +604,26 @@ export class EvidenceStore {
         this.artifactSlots += 1
         this.artifacts.set(id, metadata)
         this.capabilities.set(metadata.capabilityHash, id)
+        const runId = metadata.owner.runId
+        this.runArtifactCounts.set(runId, (this.runArtifactCounts.get(runId) ?? 0) + 1)
+        validRunHashes.set(runHash(runId), runId)
       } catch {
         await Promise.all([...files].map((suffix) => safeUnlink(this.path(id, suffix))))
       }
     }
+    for (const name of readyIndexNames) {
+      const hash = readyIndexRunHash(name)
+      const runId = hash === undefined ? undefined : validRunHashes.get(hash)
+      if (runId === undefined) {
+        await safeUnlink(join(this.root, name))
+        continue
+      }
+      const stats = await safeRegularFile(join(this.root, name))
+      if (stats && stats.size > 0) {
+        this.reserve(runId, stats.size, 0)
+        this.runIndexBytes.set(runId, stats.size)
+      }
+    }
   }
 
   /** @param {string} runId @param {number} bytes @param {number} events */
@@ -504,6 +650,39 @@ export class EvidenceStore {
       run.events -= metadata.events
       if (run.bytes === 0 && run.events === 0) this.runs.delete(metadata.owner.runId)
     }
+    this.decrementRunArtifactCount(metadata.owner.runId)
+  }
+
+  /** @param {string} runId */
+  decrementRunArtifactCount(runId) {
+    const count = (this.runArtifactCounts.get(runId) ?? 1) - 1
+    if (count <= 0) {
+      this.runArtifactCounts.delete(runId)
+      this.removeRunIndex(runId)
+    } else {
+      this.runArtifactCounts.set(runId, count)
+    }
+  }
+
+  /** @param {string} runId */
+  removeRunIndex(runId) {
+    const index = this.runIndices.get(runId)
+    if (index) {
+      index.releaseAccounting()
+      this.runIndices.delete(runId)
+      this.runIndexBytes.delete(runId)
+      try { unlinkSync(index.readyPath) } catch { /* ignore */ }
+      try { unlinkSync(index.pendingPath) } catch { /* ignore */ }
+      return
+    }
+    const reservedBytes = this.runIndexBytes.get(runId) ?? 0
+    if (reservedBytes > 0) {
+      this.reserve(runId, -reservedBytes, 0)
+    }
+    this.runIndexBytes.delete(runId)
+    const hash = runHash(runId)
+    try { unlinkSync(this.path(hash, ".index")) } catch { /* ignore */ }
+    try { unlinkSync(this.path(hash, ".index.pending")) } catch { /* ignore */ }
   }
 
   /** @param {object} owner */
@@ -939,49 +1118,6 @@ function utf8End(buffer, offset) {
   return offset
 }
 
-/** @param {string} text @param {string[]} secrets */
-function redactText(text, secrets) {
-  const merged = redactionRanges(text, secrets)
-  if (merged.length === 0) return {text, redacted: false}
-  return {text: applyRedactionRanges(text, merged, text.length), redacted: true}
-}
-
-/** @param {string} text @param {string[]} secrets */
-function redactionRanges(text, secrets) {
-  /** @type {{start: number, end: number}[]} */
-  const ranges = []
-  for (const secret of secrets) {
-    let offset = 0
-    while (offset <= text.length - secret.length) {
-      const index = text.indexOf(secret, offset)
-      if (index < 0) break
-      ranges.push({start: index, end: index + secret.length})
-      offset = index + 1
-    }
-  }
-  ranges.sort((left, right) => left.start - right.start || left.end - right.end)
-  /** @type {{start: number, end: number}[]} */
-  const merged = []
-  for (const range of ranges) {
-    const previous = merged.at(-1)
-    if (previous && range.start <= previous.end) previous.end = Math.max(previous.end, range.end)
-    else merged.push({...range})
-  }
-  return merged
-}
-
-/** @param {string} text @param {{start: number, end: number}[]} ranges @param {number} end */
-function applyRedactionRanges(text, ranges, end) {
-  let output = ""
-  let offset = 0
-  for (const range of ranges) {
-    if (range.start >= end) break
-    output += `${text.slice(offset, range.start)}[REDACTED]`
-    offset = range.end
-  }
-  return output + text.slice(offset, end)
-}
-
 /** @param {string} text @param {string[]} secrets @param {number} safeEnd */
 function redactStablePrefix(text, secrets, safeEnd) {
   const ranges = redactionRanges(text, secrets)

package/src/isolated-runtime.js

@@ -1757,7 +1757,7 @@ function validWorkerSecurity(config, host, provider = "codex") {
   ]
   return expected.every((name) => names.filter((entry) => entry === name).length === 1)
     && config.Env.includes("PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
-    && config.Env.includes("NODE_VERSION=22.17.0") && config.Env.includes("YARN_VERSION=1.22.22")
+    && config.Env.includes("NODE_VERSION=24.19.0") && config.Env.includes("YARN_VERSION=1.22.22")
 }
 
 function ownedNetworkIdentity(network, labels, identity, brokerContainer) {

package/src/jsonl-record-spool.js

@@ -4,6 +4,14 @@ import {closeSync, mkdtempSync, openSync, readFileSync, rmSync, unlinkSync, writ
 import {tmpdir} from "node:os"
 import {isAbsolute, join, normalize} from "node:path"
 
+const filesystemOperations = {writeSync}
+
+/**
+ * @typedef {object} FilesystemOperations
+ * @property {(fileDescriptor: number, buffer: Buffer, offset: number, length: number) => number} writeSync
+ *   Write bytes to a file descriptor and return the count written.
+ */
+
 /**
  * Single-owner byte-oriented spool for one worker's pending JSONL record.
  *
@@ -21,13 +29,14 @@ import {isAbsolute, join, normalize} from "node:path"
  * owner calls it on every settlement path.
  */
 export class JsonlRecordSpool {
-  /** @param {{memoryBytes: number, maxBytes: number, directory?: string}} options */
+  /** @param {{memoryBytes: number, maxBytes: number, directory?: string, filesystem?: FilesystemOperations}} options */
   constructor(options) {
     this.memoryBytes = positiveSafeInteger(options.memoryBytes, "memoryBytes")
     this.maxBytes = positiveSafeInteger(options.maxBytes, "maxBytes")
     const directory = options.directory ?? tmpdir()
     if (!isAbsolute(directory) || normalize(directory) !== directory) throw new Error("directory must be a normalized absolute path")
     this.directory = directory
+    this.filesystem = options.filesystem ?? filesystemOperations
     /** @type {Buffer[]} */
     this.segments = []
     this.pendingBytes = 0
@@ -120,7 +129,7 @@ export class JsonlRecordSpool {
     if (this.file === null) this.append(finalSegment)
     else {
       this.pendingBytes = recordBytes
-      writeSync(this.file.fd, finalSegment)
+      this.writeAll(this.file.fd, finalSegment)
     }
     const file = this.file
     if (file === null) throw new Error("JSONL record spool file is unavailable")
@@ -137,7 +146,7 @@ export class JsonlRecordSpool {
     this.pendingBytes += segment.length
     if (this.pendingBytes > this.maxBytes) throw new StdoutRecordTooLargeError()
     if (this.file !== null) {
-      writeSync(this.file.fd, segment)
+      this.writeAll(this.file.fd, segment)
       return
     }
     if (this.pendingBytes <= this.memoryBytes) {
@@ -150,9 +159,26 @@ export class JsonlRecordSpool {
     const path = join(this.ownedDirectory, "pending-record")
     const fd = openSync(path, "wx", 0o600)
     this.file = {fd, path}
-    for (const buffered of this.segments) writeSync(fd, buffered)
+    for (const buffered of this.segments) this.writeAll(fd, buffered)
     this.segments = []
-    writeSync(fd, segment)
+    this.writeAll(fd, segment)
+  }
+
+  /**
+   * Write a complete Buffer to one file descriptor, looping over short writes.
+   * @param {number} fd
+   * @param {Buffer} buffer
+   */
+  writeAll(fd, buffer) {
+    let offset = 0
+    while (offset < buffer.length) {
+      const written = this.filesystem.writeSync(fd, buffer, offset, buffer.length - offset)
+      if (written === 0) throw new Error("Spool write made zero bytes of progress")
+      if (!Number.isSafeInteger(written) || written < 0 || written > buffer.length - offset) {
+        throw new Error(`Spool write returned invalid byte count: ${written}`)
+      }
+      offset += written
+    }
   }
 
   /** Remove the current record's private spill directory, if one exists. */

package/src/kimi-model-broker.js

@@ -25,6 +25,9 @@ const UPSTREAM_URL = "https://api.kimi.com/coding/v1/chat/completions"
 export async function startKimiModelBroker(options = {}) {
   const environment = options.environment ?? process.env
   const host = safeHost(environment.THREADWIRE_KIMI_MODEL_BROKER_HOST ?? "0.0.0.0")
+  // Port 0 is accepted for test/development use: the broker binds an
+  // OS-assigned ephemeral port and exposes the actual selected port in the
+  // returned config. Production deployments normally use the fixed defaults.
   const port = portValue(environment.THREADWIRE_KIMI_MODEL_BROKER_PORT, 8791)
   const workerHost = safeHost(environment.THREADWIRE_KIMI_MODEL_BROKER_WORKER_HOST ?? "0.0.0.0")
   const workerPort = portValue(environment.THREADWIRE_KIMI_MODEL_BROKER_WORKER_PORT, 8792)
@@ -143,10 +146,23 @@ export async function startKimiModelBroker(options = {}) {
     socket.once("close", () => controlSockets.delete(socket))
   })
   await listen(workerServer, workerPort, workerHost)
+  const workerAddress = workerServer.address()
+  if (workerAddress === null || typeof workerAddress === "string") {
+    await boundedClose(workerServer)
+    throw new Error("Kimi model broker worker listener address unavailable")
+  }
+  const actualWorkerPort = workerAddress.port
   try { await listen(server, port, host) } catch (error) {
     await boundedClose(workerServer)
     throw error
   }
+  const address = server.address()
+  if (address === null || typeof address === "string") {
+    await boundedClose(server)
+    await boundedClose(workerServer)
+    throw new Error("Kimi model broker listener address unavailable")
+  }
+  const actualPort = address.port
   return {
     server,
     workerServer,
@@ -159,7 +175,7 @@ export async function startKimiModelBroker(options = {}) {
       for (const socket of workerSockets) socket.destroy()
       await Promise.all([boundedClose(server), boundedClose(workerServer)])
     },
-    config: {host, port, workerHost, workerPort, workerBind, models: [...approvedModels.keys()]}
+    config: {host, port: actualPort, workerHost, workerPort: actualWorkerPort, workerBind, models: [...approvedModels.keys()]}
   }
 }
 
@@ -326,7 +342,7 @@ function bindSetting(value, name) {
 function portValue(value, fallback) {
   if (value === undefined) return fallback
   const number = Number(value)
-  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(number) || number < 1 || number > 65535) throw new Error("Invalid Kimi model broker port")
+  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(number) || number < 0 || number > 65535) throw new Error("Invalid Kimi model broker port")
   return number
 }
 /** @param {string | null} value @returns {string} */

package/src/redaction.js

@@ -0,0 +1,50 @@
+/**
+ * Bounded literal-secret redaction helpers.
+ *
+ * These are used by both evidence artifacts and the per-run SQLite index, so
+ * they live in a separate module to avoid a circular dependency between the
+ * store and index implementations.
+ */
+
+/** @param {string} text @param {string[]} secrets */
+export function redactText(text, secrets) {
+  const merged = redactionRanges(text, secrets)
+  if (merged.length === 0) return {text, redacted: false}
+  return {text: applyRedactionRanges(text, merged, text.length), redacted: true}
+}
+
+/** @param {string} text @param {string[]} secrets */
+export function redactionRanges(text, secrets) {
+  /** @type {{start: number, end: number}[]} */
+  const ranges = []
+  for (const secret of secrets) {
+    let offset = 0
+    while (offset <= text.length - secret.length) {
+      const index = text.indexOf(secret, offset)
+      if (index < 0) break
+      ranges.push({start: index, end: index + secret.length})
+      offset = index + 1
+    }
+  }
+  ranges.sort((left, right) => left.start - right.start || left.end - right.end)
+  /** @type {{start: number, end: number}[]} */
+  const merged = []
+  for (const range of ranges) {
+    const previous = merged.at(-1)
+    if (previous && range.start <= previous.end) previous.end = Math.max(previous.end, range.end)
+    else merged.push({...range})
+  }
+  return merged
+}
+
+/** @param {string} text @param {{start: number, end: number}[]} ranges @param {number} end */
+export function applyRedactionRanges(text, ranges, end) {
+  let output = ""
+  let offset = 0
+  for (const range of ranges) {
+    if (range.start >= end) break
+    output += `${text.slice(offset, range.start)}[REDACTED]`
+    offset = range.end
+  }
+  return output + text.slice(offset, end)
+}

package/src/run-worker.js

@@ -27,13 +27,15 @@ export function runWorker(options) {
   const spawnImplementation = options.spawnImplementation ?? nodeSpawn
   const killProcess = options.killProcess ?? ((pid, signal) => process.kill(pid, signal))
   // Attempt-owned liveness probe: signal 0 against the exact process group.
-  // Never a name match or a broad process scan.
+  // Never a name match or a broad process scan. Only ESRCH/EINVAL mean the
+  // group is actually gone; EPERM means a process exists but we cannot signal
+  // it, so it must be treated as alive to avoid false settlement.
   const probeProcessGroup = options.probeProcessGroup ?? ((pid) => {
     try {
       process.kill(-pid, 0)
       return true
-    } catch {
-      return false
+    } catch (error) {
+      return !isProcessGoneError(error)
     }
   })
   const setTimer = options.setTimer ?? ((callback, milliseconds) => setTimeout(callback, milliseconds))
@@ -491,6 +493,11 @@ function signalExitCode(signal) {
   return 128 + (osConstants.signals[signal] ?? 0)
 }
 
+/** @param {unknown} error @returns {boolean} */
+function isProcessGoneError(error) {
+  return error instanceof Error && "code" in error && (error.code === "ESRCH" || error.code === "EINVAL")
+}
+
 /** @param {unknown} value @returns {value is number} */
 function isPositiveSafeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0

package/src/telegram-ingress/core.js

@@ -4,6 +4,7 @@ import {createHash, randomUUID, timingSafeEqual} from "node:crypto"
 import {abortable} from "../absolute-deadline.js"
 import {DelegatedResultAdmission} from "../delegated-result-admission.js"
 import {evidenceTelegramDestination} from "../evidence-store.js"
+import {workerEventToIndexEvent} from "../evidence-index.js"
 import {NoticeQueue} from "../notice-queue.js"
 import {createFetchTransport} from "../notifiers/fetch-transport.js"
 import {createTelegramSender} from "../notifiers/telegram.js"
@@ -164,7 +165,13 @@ export async function dispatchWorker(job, config, dependencies = {}) {
       runId: deliveryIdentity
     })
     if (evidenceOwner !== undefined) {
+      if (typeof dependencies.evidenceStore?.ensureRunIndex === "function") {
+        dependencies.evidenceStore.ensureRunIndex(evidenceOwner, {provider: job.provider})
+      }
       const redactions = await collectEvidenceRedactions(dependencies.providerEnvironment ?? {})
+      if (typeof dependencies.evidenceStore?.setRunIndexRedactions === "function") {
+        dependencies.evidenceStore.setRunIndexRedactions(evidenceOwner, redactions)
+      }
       evidence = await dependencies.evidenceStore?.createArtifact(evidenceOwner, {
         contentType: "text/plain; charset=utf-8",
         redactions
@@ -188,6 +195,7 @@ export async function dispatchWorker(job, config, dependencies = {}) {
   /** @param {import("../types.js").WorkerEvent} event */
   const acceptEvent = async (event) => {
     if (event.type === "text-delta") admission.acceptConclusionEvent(event)
+    await recordEvidenceEvent(workerEventToIndexEvent(event, job.provider))
     try {
       await control.accept(event)
     } catch (error) {
@@ -204,6 +212,11 @@ export async function dispatchWorker(job, config, dependencies = {}) {
       dependencies.activity?.recordSession(provider.name, id)
     }
   }
+  /** @param {import("../evidence-index.js").EvidenceIndexEvent} event */
+  const recordEvidenceEvent = (event) => {
+    if (evidenceOwner === undefined || typeof dependencies.evidenceStore?.recordEvent !== "function") return Promise.resolve()
+    return dependencies.evidenceStore.recordEvent(evidenceOwner, event)
+  }
   /** @param {number} exitCode */
   const finalizeEvidence = async (exitCode) => {
     if (resultEvidence === undefined || resultEvidenceFinalized) return
@@ -223,9 +236,23 @@ export async function dispatchWorker(job, config, dependencies = {}) {
       state: /** @type {"completed" | "failed"} */ (exitCode === 0 ? "completed" : "failed"),
       exitCode
     }
-    await resultEvidence.append("provider-result", `${JSON.stringify(admission.createProviderResult(terminal))}\n`)
+    const providerResult = `${JSON.stringify(admission.createProviderResult(terminal))}\n`
+    await resultEvidence.append("provider-result", providerResult)
+    await recordEvidenceEvent({
+      kind: "provider_result",
+      artifactId: resultEvidence.metadata?.id,
+      provider: job.provider,
+      metadata: {terminal, length: Buffer.byteLength(providerResult, "utf8")}
+    })
     await resultEvidence.finalize()
     resultEvidenceFinalized = true
+    if (evidenceOwner !== undefined && typeof dependencies.evidenceStore?.finalizeRunIndex === "function") {
+      try {
+        await dependencies.evidenceStore.finalizeRunIndex(evidenceOwner, terminal)
+      } catch (error) {
+        evidenceError ??= error
+      }
+    }
   }
   const finishDelivery = async () => {
     if (resultEvidence !== undefined && deliveryError === undefined) {
@@ -254,7 +281,16 @@ export async function dispatchWorker(job, config, dependencies = {}) {
   }
   let evidenceTransferred = false
   try {
-    await evidence?.append("prompt", `prompt\n${job.prompt}\nprovider-stream\n`)
+    if (evidence !== undefined) {
+      const promptEvidence = `prompt\n${job.prompt}\nprovider-stream\n`
+      await evidence.append("prompt", promptEvidence)
+      await recordEvidenceEvent({
+        kind: "prompt",
+        artifactId: evidence.metadata?.id,
+        provider: job.provider,
+        metadata: {length: Buffer.byteLength(promptEvidence, "utf8")}
+      })
+    }
 
     if (isolatedRuntimeClient !== undefined) {
       evidenceTransferred = true
@@ -277,8 +313,20 @@ export async function dispatchWorker(job, config, dependencies = {}) {
           onEvent: acceptEvent,
           onRecord: async (record) => acceptRecord(record),
           ...(job.provider === "kimi" ? {} : {
-            onStdoutChunk: (chunk) => evidence?.append("provider-stdout", chunk),
-            onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
+            onStdoutChunk: (chunk) => {
+              if (evidence === undefined) return undefined
+              return Promise.all([
+                evidence.append("provider-stdout", chunk),
+                recordEvidenceEvent({kind: "provider_stdout", artifactId: evidence.metadata?.id, provider: job.provider, metadata: {length: chunk.length}})
+              ]).then(() => {})
+            },
+            onStderrChunk: (chunk) => {
+              if (evidence === undefined) return undefined
+              return Promise.all([
+                evidence.append("provider-stderr", chunk),
+                recordEvidenceEvent({kind: "provider_stderr", artifactId: evidence.metadata?.id, provider: job.provider, metadata: {length: chunk.length}})
+              ]).then(() => {})
+            }
           })
         })
         let exitCode = 2
@@ -382,8 +430,20 @@ export async function dispatchWorker(job, config, dependencies = {}) {
         spawnGate.resolve()
       },
       onRecord: async (record) => acceptRecord(record),
-      onStdoutChunk: (chunk) => evidence?.append("provider-stdout", chunk),
-      onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
+      onStdoutChunk: (chunk) => {
+        if (evidence === undefined) return undefined
+        return Promise.all([
+          evidence.append("provider-stdout", chunk),
+          recordEvidenceEvent({kind: "provider_stdout", artifactId: evidence.metadata?.id, provider: job.provider, metadata: {length: chunk.length}})
+        ]).then(() => {})
+      },
+      onStderrChunk: (chunk) => {
+        if (evidence === undefined) return undefined
+        return Promise.all([
+          evidence.append("provider-stderr", chunk),
+          recordEvidenceEvent({kind: "provider_stderr", artifactId: evidence.metadata?.id, provider: job.provider, metadata: {length: chunk.length}})
+        ]).then(() => {})
+      }
     })
 
     // Detached observer: never resolves the spawn gate from process exit — only