threadwire 0.1.21 → 0.1.23

package/src/cli.js

@@ -15,6 +15,7 @@ import {buildProviderEnvironment, collectEvidenceRedactions, parseTelegramReques
 import {WorkerControl} from "./worker-control.js"
 import {EvidenceStore} from "./evidence-store.js"
 import {ContextBudgetMetrics} from "./context-budget-metrics.js"
+import {workerEventToIndexEvent} from "./evidence-index.js"
 import {isolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
 import {validateRelayWriteProviderArguments} from "./relay-write.js"
 import {abortable} from "./absolute-deadline.js"
@@ -40,6 +41,8 @@ const HELP = `Usage: threadwire run --provider <codex|claude|kimi|opencode> --ta
   [-- <provider arguments...>]
        threadwire evidence read --handle <opaque-handle>
   (--bytes <offset>:<limit> | --lines <start>:<limit> | --query <literal> --context-bytes <limit>)
+       threadwire evidence inspect --handle <opaque-handle>
+  (--summary | --events [--kind <kind>] [--after <order>] [--before <order>] [--limit <positive-integer>] | --failures [--after <order>] [--limit <positive-integer>])
        threadwire capacity [--provider <codex|kimi>]...
   [--short-reserve-percent <0-100>] [--long-reserve-percent <0-100>]
   [--timeout-ms <positive-integer>]
@@ -47,7 +50,7 @@ const HELP = `Usage: threadwire run --provider <codex|claude|kimi|opencode> --ta
   (Emits one closed versioned JSON status document from the activity log.)`
 
 /** @typedef {{provider: string, target: string, cwd: string, toolMessages: boolean, relayWrite: boolean, prompt?: string, promptFile?: string, processNumber?: number, maxOutputLength?: number, resumeSession?: string, transcript?: string, activityLog?: string, providerArguments: string[]}} ParsedArguments */
-/** @typedef {{evidenceRead: true, request: unknown}} EvidenceParsedArguments */
+/** @typedef {{evidenceRead: true, request: unknown} | {evidenceInspect: true, request: unknown}} EvidenceParsedArguments */
 /** @typedef {{capacity: true, providers: import("./provider-capacity.js").CapacityProvider[], shortReservePercent: number, longReservePercent: number, timeoutMs: number}} CapacityParsedArguments */
 /** @typedef {{probe: (provider: import("./provider-capacity.js").CapacityProvider, timeoutMs?: number) => Promise<import("./provider-capacity.js").CapacityCandidate>}} CapacityProbeDependency */
 /**
@@ -128,31 +131,77 @@ export function parseArguments(arguments_) {
 }
 
 /** @param {string[]} arguments_ @returns {EvidenceParsedArguments} */
-function parseEvidenceArguments(arguments_) {
-  if (arguments_[1] !== "read") throw new Error(HELP)
-  /** @type {Record<string, string>} */
+export function parseEvidenceArguments(arguments_) {
+  const subcommand = arguments_[1]
+  if (subcommand !== "read" && subcommand !== "inspect") throw new Error(HELP)
+  /** @type {Record<string, string | boolean>} */
   const options = {}
-  for (let index = 2; index < arguments_.length; index += 2) {
+  let index = 2
+  while (index < arguments_.length) {
     const name = arguments_[index]
+    if (name === "--summary" || name === "--events" || name === "--failures") {
+      if (options[name] !== undefined) throw new Error(`Duplicate evidence option: ${name}`)
+      options[name] = true
+      index += 1
+      continue
+    }
     const value = arguments_[index + 1]
-    if (!name || !value || !["--handle", "--bytes", "--lines", "--query", "--context-bytes"].includes(name)) throw new Error(HELP)
+    if (!name || value === undefined) throw new Error(HELP)
+    const readOptions = ["--handle", "--bytes", "--lines", "--query", "--context-bytes"]
+    const inspectOptions = ["--handle", "--kind", "--after", "--before", "--limit"]
+    const allowed = subcommand === "read" ? readOptions : inspectOptions
+    if (!allowed.includes(name)) throw new Error(HELP)
     if (options[name] !== undefined) throw new Error(`Duplicate evidence option: ${name}`)
     options[name] = value
+    index += 2
   }
-  const handle = options["--handle"]
+  const handle = /** @type {string | undefined} */ (options["--handle"])
   if (!handle) throw new Error("--handle is required")
-  const selectors = ["--bytes", "--lines", "--query"].filter((name) => options[name] !== undefined)
-  if (selectors.length !== 1) throw new Error("Exactly one bounded evidence selector is required")
-  let request
-  if (options["--bytes"]) request = {handle, bytes: rangePair(options["--bytes"], true)}
-  else if (options["--lines"]) request = {handle, lines: rangePair(options["--lines"], false)}
-  else {
-    const context = options["--context-bytes"]
-    if (!context) throw new Error("--context-bytes is required with --query")
-    request = {handle, query: {literal: options["--query"], limit: 1, contextBytes: positiveInteger(context, "--context-bytes")}}
+  if (subcommand === "read") {
+    const selectors = ["--bytes", "--lines", "--query"].filter((name) => options[name] !== undefined)
+    if (selectors.length !== 1) throw new Error("Exactly one bounded evidence selector is required")
+    let request
+    if (options["--bytes"]) request = {handle, bytes: rangePair(/** @type {string} */ (options["--bytes"]), true)}
+    else if (options["--lines"]) request = {handle, lines: rangePair(/** @type {string} */ (options["--lines"]), false)}
+    else {
+      const context = options["--context-bytes"]
+      if (!context) throw new Error("--context-bytes is required with --query")
+      request = {handle, query: {literal: options["--query"], limit: 1, contextBytes: positiveInteger(/** @type {string} */ (context), "--context-bytes")}}
+    }
+    if (options["--query"] === undefined && options["--context-bytes"] !== undefined) throw new Error("--context-bytes requires --query")
+    return {evidenceRead: true, request}
+  }
+  const selectors = ["--summary", "--events", "--failures"].filter((name) => options[name] !== undefined)
+  if (selectors.length !== 1) throw new Error("Evidence inspect requires exactly one fixed selector")
+  const allowed = options["--summary"]
+    ? ["--handle", "--summary"]
+    : options["--events"]
+      ? ["--handle", "--events", "--kind", "--after", "--before", "--limit"]
+      : ["--handle", "--failures", "--after", "--limit"]
+  const allowedSet = new Set(allowed)
+  for (const key of Object.keys(options)) {
+    if (!allowedSet.has(key)) throw new Error(`Incompatible evidence inspect flag: ${key}`)
   }
-  if (options["--query"] === undefined && options["--context-bytes"] !== undefined) throw new Error("--context-bytes requires --query")
-  return {evidenceRead: true, request}
+  /** @type {import("./evidence-index.js").EvidenceInspectRequest} */
+  let request = {handle}
+  if (options["--summary"]) {
+    request = {...request, summary: true}
+  } else if (options["--events"]) {
+    /** @type {NonNullable<import("./evidence-index.js").EvidenceInspectRequest["events"]>} */
+    const events = {}
+    if (options["--kind"]) events.kind = /** @type {string} */ (options["--kind"])
+    if (options["--after"]) events.after = positiveInteger(/** @type {string} */ (options["--after"]), "--after")
+    if (options["--before"]) events.before = positiveInteger(/** @type {string} */ (options["--before"]), "--before")
+    if (options["--limit"]) events.limit = positiveInteger(/** @type {string} */ (options["--limit"]), "--limit")
+    request = {...request, events}
+  } else {
+    /** @type {NonNullable<import("./evidence-index.js").EvidenceInspectRequest["failures"]>} */
+    const failures = {}
+    if (options["--after"]) failures.after = positiveInteger(/** @type {string} */ (options["--after"]), "--after")
+    if (options["--limit"]) failures.limit = positiveInteger(/** @type {string} */ (options["--limit"]), "--limit")
+    request = {...request, failures}
+  }
+  return {evidenceInspect: true, request}
 }
 
 /** @param {string[]} arguments_ @returns {CapacityParsedArguments | {help: true}} */
@@ -292,13 +341,15 @@ export async function main(arguments_, dependencies = {}) {
       })}\n`)
       return selection === null ? 2 : 0
     }
-    if ("evidenceRead" in parsed) {
+    if ("evidenceRead" in parsed || "evidenceInspect" in parsed) {
       const root = evidenceRoot(sourceEnvironment.THREADWIRE_EVIDENCE_ROOT)
       if (!root) throw new Error("THREADWIRE_EVIDENCE_ROOT is required")
       if (validateOnly) return 0
       const store = await EvidenceStore.open({root})
       try {
-        const result = await store.readBearer(parsed.request)
+        const result = "evidenceRead" in parsed
+          ? await store.readBearer(parsed.request)
+          : await store.inspectBearer(parsed.request)
         output.write(`${JSON.stringify(result)}\n`)
         return 0
       } finally {
@@ -360,6 +411,11 @@ export async function main(arguments_, dependencies = {}) {
     let resultEvidenceBytes = 0
     const deliveryIdentity = randomUUID()
     const launchDeadline = isolatedPreflight?.deadline
+    /** @param {import("./evidence-index.js").EvidenceIndexEvent} event */
+    const recordEvidenceEvent = (event) => {
+      if (evidenceStore === undefined || evidenceOwner === undefined) return Promise.resolve()
+      return evidenceStore.recordEvent(evidenceOwner, event)
+    }
     try {
       environment = await boundedLaunch(resolveFileBackedSettings(
         sourceEnvironment,
@@ -381,7 +437,9 @@ export async function main(arguments_, dependencies = {}) {
             : "file",
           runId: deliveryIdentity
         })
+        evidenceStore.ensureRunIndex(evidenceOwner, {provider: parsed.provider})
         const redactions = await boundedLaunch(collectEvidenceRedactions(environment), launchDeadline)
+        evidenceStore.setRunIndexRedactions(evidenceOwner, redactions)
         evidence = await evidenceStore.createArtifact(evidenceOwner, {
           contentType: "text/plain; charset=utf-8",
           redactions
@@ -404,6 +462,12 @@ export async function main(arguments_, dependencies = {}) {
       if (evidence !== undefined) {
         const promptEvidence = `prompt\n${prompt}\nprovider-stream\n`
         await boundedLaunch(evidence.append("prompt", promptEvidence), launchDeadline)
+        await recordEvidenceEvent({
+          kind: "prompt",
+          artifactId: evidence.metadata.id,
+          provider: parsed.provider,
+          metadata: {length: Buffer.byteLength(promptEvidence, "utf8")}
+        })
         evidencePayloadBytes += Buffer.byteLength(promptEvidence, "utf8")
       }
       const providerEnvironment = buildProviderEnvironment(environment, {
@@ -455,6 +519,7 @@ export async function main(arguments_, dependencies = {}) {
           else if (event.type === "tool") activity?.recordActivity(provider.name, "tool")
           else if (event.type === "lifecycle") activity?.recordActivity(provider.name, "lifecycle")
           acceptAdmissionEvent(admission, event)
+          await recordEvidenceEvent(workerEventToIndexEvent(event, parsed.provider))
           if (control !== undefined) {
             try {
               await control.accept(event)
@@ -480,13 +545,29 @@ export async function main(arguments_, dependencies = {}) {
           metrics.recordRawChildChunk("provider_stdout", chunk.length)
           metrics.recordRejected("provider_stream", chunk.length)
           if (evidence === undefined) return undefined
-          return evidence.append("provider-stdout", chunk).then(() => { evidencePayloadBytes += chunk.length })
+          return Promise.all([
+            evidence.append("provider-stdout", chunk),
+            recordEvidenceEvent({
+              kind: "provider_stdout",
+              artifactId: evidence.metadata.id,
+              provider: parsed.provider,
+              metadata: {length: chunk.length}
+            })
+          ]).then(() => { evidencePayloadBytes += chunk.length })
         },
         onStderrChunk: (chunk) => {
           metrics.recordRawChildChunk("provider_stderr", chunk.length)
           metrics.recordRejected("stderr", chunk.length)
           if (evidence === undefined) return undefined
-          return evidence.append("provider-stderr", chunk).then(() => { evidencePayloadBytes += chunk.length })
+          return Promise.all([
+            evidence.append("provider-stderr", chunk),
+            recordEvidenceEvent({
+              kind: "provider_stderr",
+              artifactId: evidence.metadata.id,
+              provider: parsed.provider,
+              metadata: {length: chunk.length}
+            })
+          ]).then(() => { evidencePayloadBytes += chunk.length })
         }
       }
       let exitCode
@@ -520,6 +601,12 @@ export async function main(arguments_, dependencies = {}) {
           const providerResult = admission.createProviderResult(terminal)
           const serializedProviderResult = `${JSON.stringify(providerResult)}\n`
           await resultEvidence.append("provider-result", serializedProviderResult)
+          await recordEvidenceEvent({
+            kind: "provider_result",
+            artifactId: resultEvidence.metadata.id,
+            provider: parsed.provider,
+            metadata: {terminal, length: Buffer.byteLength(serializedProviderResult, "utf8")}
+          })
           const resultArtifact = await resultEvidence.finalize()
           resultEvidenceBytes = resultArtifact.bytes
           resultEvidenceFinalized = true
@@ -550,7 +637,14 @@ export async function main(arguments_, dependencies = {}) {
             evidencePayloadBytes + resultEvidenceBytes,
             2
           )
-          await evidence.append("context-metrics", `${JSON.stringify(metrics.snapshot())}\n`)
+          const metricsSnapshot = `${JSON.stringify(metrics.snapshot())}\n`
+          await evidence.append("context-metrics", metricsSnapshot)
+          await recordEvidenceEvent({
+            kind: "context_metrics",
+            artifactId: evidence.metadata.id,
+            provider: parsed.provider,
+            metadata: {length: Buffer.byteLength(metricsSnapshot, "utf8")}
+          })
           const artifact = await evidence.finalize()
           assertArtifactProjection(artifact.bytes + resultEvidenceBytes, projectedArtifactBytes)
         } catch (error) {
@@ -563,6 +657,13 @@ export async function main(arguments_, dependencies = {}) {
       } else if (resultEvidenceFinalized) {
         metrics.recordArtifact(resultEvidenceBytes, 1)
       }
+      if (evidenceStore !== undefined && evidenceOwner !== undefined && evidenceError === undefined) {
+        try {
+          await evidenceStore.finalizeRunIndex(evidenceOwner, terminal)
+        } catch (error) {
+          evidenceError ??= error
+        }
+      }
       admission.complete({state: terminalExitCode === 0 ? "completed" : "failed", exitCode: terminalExitCode})
       if (
         destination.type === "telegram" && resultEvidenceFinalized