threadwire 0.1.5 → 0.1.8

package/src/relay.js

@@ -45,7 +45,7 @@ export class Relay {
       return
     }
     const text = this.renderActivity(event)
-    if (text) this.queue.enqueue({text, label: `${this.label} `})
+    if (text) this.queue.enqueue({text, label: `${this.label} `, metricClass: event.type})
   }
 
   /**
@@ -60,7 +60,7 @@ export class Relay {
     if (event.phase === "started") {
       const description = this.toolDescription(event)
       this.activeToolDescriptions.set(event.key, {description, hasDetail: event.detail !== undefined && event.detail.length > 0})
-      this.queue.enqueue({activity: {key: event.key, phase: "started"}, text: `🛠 ${this.label} Tool: ${description}`})
+      this.queue.enqueue({activity: {key: event.key, phase: "started"}, text: `🛠 ${this.label} Tool: ${description}`, metricClass: "tool"})
       return
     }
     const stored = this.activeToolDescriptions.get(event.key)
@@ -71,10 +71,10 @@ export class Relay {
     const status = `✅ ${this.label} Tool: ${description}`
     const html = renderCompletedOutput(status, event.output, this.outputMessageLimit())
     if (html === undefined) {
-      this.queue.enqueue({activity: {key: event.key, phase: "finished"}, text: status})
+      this.queue.enqueue({activity: {key: event.key, phase: "finished"}, text: status, metricClass: "tool"})
       return
     }
-    this.queue.enqueue({activity: {key: event.key, phase: "finished"}, text: html, parseMode: "HTML"})
+    this.queue.enqueue({activity: {key: event.key, phase: "finished"}, text: html, parseMode: "HTML", metricClass: "tool"})
   }
 
   /**
@@ -165,10 +165,10 @@ export class Relay {
 
   /** @param {string} text */
   enqueueAssistant(text) {
-    if (this.inJavaScriptFence) this.queue.enqueue({text, format: "javascript-code", label: `${this.label} Assistant:`})
+    if (this.inJavaScriptFence) this.queue.enqueue({text, format: "javascript-code", label: `${this.label} Assistant:`, metricClass: "assistant"})
     else {
       const label = `${this.label} Assistant: `
-      this.queue.enqueue({text: `${label}${text.replaceAll(/(\r\n|[\n\r\u2028\u2029])(?=.)/gu, `$1${label}`)}`, label, batchSeparator: ""})
+      this.queue.enqueue({text: `${label}${text.replaceAll(/(\r\n|[\n\r\u2028\u2029])(?=.)/gu, `$1${label}`)}`, label, batchSeparator: "", metricClass: "assistant"})
     }
   }
 

package/src/run-worker.js

@@ -6,17 +6,25 @@ import {StringDecoder} from "node:string_decoder"
 import {buildProviderEnvironment} from "./telegram-ingress/config.js"
 
 const DEFAULT_MAX_STDOUT_RECORD_BYTES = 1_048_576
+const DEFAULT_TERMINATION_GRACE_PERIOD_MS = 5_000
 
 /**
- * @typedef {{executable: string, arguments: string[], cwd: string, environment?: NodeJS.ProcessEnv, parse: (record: unknown) => import("./types.js").WorkerEvent[], onEvent: (event: import("./types.js").WorkerEvent) => void, onSpawn?: (pid: number) => void, onRecord?: (record: unknown) => void, spawnImplementation?: typeof nodeSpawn, maxStdoutRecordBytes?: number}} RunWorkerOptions
+ * @typedef {{executable: string, arguments: string[], cwd: string, environment?: NodeJS.ProcessEnv, parse: (record: unknown) => import("./types.js").WorkerEvent[], onEvent: (event: import("./types.js").WorkerEvent) => void | Promise<void>, onSpawn?: (pid: number) => void, onRecord?: (record: unknown) => void | Promise<void>, onStdoutChunk?: (chunk: Buffer) => void | Promise<void>, onStderrChunk?: (chunk: Buffer) => void | Promise<void>, spawnImplementation?: typeof nodeSpawn, maxStdoutRecordBytes?: number, terminationGracePeriodMs?: number, setTimer?: (callback: () => void, milliseconds: number) => unknown, clearTimer?: (handle: unknown) => void, platform?: NodeJS.Platform, killProcess?: (pid: number, signal: NodeJS.Signals) => boolean}} RunWorkerOptions
  */
 
 /** @param {RunWorkerOptions} options @returns {Promise<number>} */
 export function runWorker(options) {
   const maxStdoutRecordBytes = positiveSafeInteger(options.maxStdoutRecordBytes ?? DEFAULT_MAX_STDOUT_RECORD_BYTES, "maxStdoutRecordBytes")
+  const terminationGracePeriodMs = positiveSafeInteger(options.terminationGracePeriodMs ?? DEFAULT_TERMINATION_GRACE_PERIOD_MS, "terminationGracePeriodMs")
+  const platform = options.platform ?? process.platform
   const spawnImplementation = options.spawnImplementation ?? nodeSpawn
+  const killProcess = options.killProcess ?? ((pid, signal) => process.kill(pid, signal))
+  const setTimer = options.setTimer ?? ((callback, milliseconds) => setTimeout(callback, milliseconds))
+  const clearTimer = options.clearTimer ?? ((handle) => clearTimeout(/** @type {ReturnType<typeof setTimeout>} */ (handle)))
+  const useDetachedProcessGroup = platform !== "win32"
   const child = spawnImplementation(options.executable, options.arguments, {
     cwd: options.cwd,
+    detached: useDetachedProcessGroup,
     env: childEnvironment(options.environment ?? process.env),
     shell: false,
     stdio: ["ignore", "pipe", "pipe"]
@@ -28,48 +36,124 @@ export function runWorker(options) {
 
   return new Promise((resolve, reject) => {
     let settled = false
+    /** @type {number | null} */
+    let closeCode = null
+    /** @type {NodeJS.Signals | null} */
+    let closeSignal = null
+    let closeSeen = false
+    /** @type {Promise<void>} */
+    let consumer = Promise.resolve()
+    /** @type {Error | null} */
+    let shutdownError = null
+    /** @type {unknown | null} */
+    let terminationTimer = null
+    const processGroupPid = useDetachedProcessGroup && isPositiveSafeInteger(child.pid) ? child.pid : null
     /** @param {NodeJS.Signals} signal */
-    const forwardSignal = (signal) => child.kill(signal)
+    const forwardSignal = (signal) => signalChildTree(child, processGroupPid, signal, killProcess)
     const onInterrupt = () => forwardSignal("SIGINT")
     const onTerminate = () => forwardSignal("SIGTERM")
-    /** @param {Error} error @param {boolean} [terminateChild] */
-    const fail = (error, terminateChild = true) => {
+    const clearTerminationTimer = () => {
+      if (terminationTimer === null) return
+      clearTimer(terminationTimer)
+      terminationTimer = null
+    }
+    const detachForShutdown = () => {
+      child.stdout?.removeListener("data", onStdout)
+      child.stderr?.removeListener("data", onStderr)
+      child.removeListener("spawn", onSpawn)
+      child.removeListener("error", onError)
+      removeSignalHandlers(onInterrupt, onTerminate)
+    }
+    const cleanup = () => {
+      detachForShutdown()
+      clearTerminationTimer()
+      child.removeListener("close", onClose)
+    }
+    /** @param {Error} error */
+    const rejectAndCleanup = (error) => {
       if (settled) return
       settled = true
       cleanup()
-      if (terminateChild) {
-        try { child.kill("SIGTERM") } catch { /* Child may already be gone. */ }
-      }
       reject(error)
     }
+    /** @param {Error} error @param {boolean} [terminateChild] */
+    const fail = (error, terminateChild = true) => {
+      if (settled || shutdownError) return
+      if (!terminateChild) {
+        rejectAndCleanup(error)
+        return
+      }
+      if (closeSeen) {
+        if (processGroupPid === null) {
+          try {
+            forwardSignal("SIGTERM")
+          } catch {
+            /* Child may already be gone. */
+          }
+        }
+        rejectAndCleanup(error)
+        return
+      }
+      shutdownError = error
+      detachForShutdown()
+      try {
+        forwardSignal("SIGTERM")
+      } catch {
+        /* Child may already be gone. */
+      }
+      terminationTimer = setTimer(() => {
+        if (settled || shutdownError === null) return
+        terminationTimer = null
+        try {
+          forwardSignal("SIGKILL")
+        } catch {
+          /* Child may already be gone. */
+        }
+        rejectAndCleanup(shutdownError)
+      }, terminationGracePeriodMs)
+    }
+    /**
+     * @param {() => Promise<void>} task
+     * @param {NodeJS.ReadableStream | undefined} stream
+     */
+    const enqueueConsumer = (task, stream) => {
+      stream?.pause()
+      consumer = consumer
+        .then(async () => {
+          if (settled || shutdownError) return
+          await task()
+        })
+        .then(() => {
+          stream?.resume()
+          if (closeSeen) void finalizeClose()
+        })
+        .catch((error) => {
+          fail(toError(error))
+        })
+    }
     /** @param {Buffer | string} chunk */
     const onStdout = (chunk) => {
-      if (settled) return
-      try {
+      if (settled || shutdownError) return
+      enqueueConsumer(async () => {
         const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+        await options.onStdoutChunk?.(bytes)
         stdoutRecordBytes = nextRecordByteCount(bytes, stdoutRecordBytes, maxStdoutRecordBytes)
         stdoutBuffer += stdoutDecoder.write(bytes)
-        stdoutBuffer = drainLines(stdoutBuffer, options.parse, options.onEvent, options.onRecord)
-      } catch (error) {
-        fail(toError(error))
-      }
+        stdoutBuffer = await drainLines(stdoutBuffer, options.parse, options.onEvent, options.onRecord)
+      }, child.stdout)
     }
-    const onStderr = () => {
-      if (settled || stderrSeen) return
-      stderrSeen = true
-      try {
-        options.onEvent({type: "diagnostic", level: "warning", summary: "Worker wrote diagnostics to stderr"})
-      } catch (error) {
-        fail(toError(error))
-      }
-    }
-    const cleanup = () => {
-      child.stdout?.removeListener("data", onStdout)
-      child.stderr?.removeListener("data", onStderr)
-      child.removeListener("spawn", onSpawn)
-      child.removeListener("error", onError)
-      child.removeListener("close", onClose)
-      removeSignalHandlers(onInterrupt, onTerminate)
+    /** @param {Buffer | string} chunk */
+    const onStderr = (chunk) => {
+      if (settled || shutdownError) return
+      enqueueConsumer(
+        async () => {
+          await options.onStderrChunk?.(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+          if (stderrSeen) return
+          stderrSeen = true
+          await options.onEvent({type: "diagnostic", level: "warning", summary: "Worker wrote diagnostics to stderr"})
+        },
+        child.stderr
+      )
     }
     /** @param {Error} error */
     const onError = (error) => fail(error, false)
@@ -82,19 +166,36 @@ export function runWorker(options) {
         fail(toError(error))
       }
     }
-    /** @param {number | null} code @param {NodeJS.Signals | null} signal */
-    const onClose = (code, signal) => {
+    const finalizeClose = async () => {
       if (settled) return
+      if (shutdownError) {
+        settled = true
+        cleanup()
+        reject(shutdownError)
+        return
+      }
       try {
+        await consumer
+        if (settled) return
         stdoutBuffer += stdoutDecoder.end()
-        if (stdoutBuffer.trim().length > 0) parseLine(stdoutBuffer, options.parse, options.onEvent, options.onRecord)
+        if (stdoutBuffer.trim().length > 0) await parseLine(stdoutBuffer, options.parse, options.onEvent, options.onRecord)
       } catch (error) {
         fail(toError(error), false)
         return
       }
       settled = true
       cleanup()
-      resolve(code ?? signalExitCode(signal))
+      resolve(closeCode ?? signalExitCode(closeSignal))
+    }
+    /** @param {number | null} code @param {NodeJS.Signals | null} signal */
+    const onClose = (code, signal) => {
+      if (settled) return
+      closeSeen = true
+      removeSignalHandlers(onInterrupt, onTerminate)
+      closeCode = code
+      closeSignal = signal
+      clearTerminationTimer()
+      void finalizeClose()
     }
     child.stdout?.on("data", onStdout)
     child.stderr?.on("data", onStderr)
@@ -125,26 +226,32 @@ export function childEnvironment(environment = process.env) {
 }
 
 /** @param {string} buffer @param {RunWorkerOptions["parse"]} parse @param {RunWorkerOptions["onEvent"]} onEvent @param {RunWorkerOptions["onRecord"]} onRecord */
-function drainLines(buffer, parse, onEvent, onRecord) {
+async function drainLines(buffer, parse, onEvent, onRecord) {
   const lines = buffer.split("\n")
   const tail = lines.pop() ?? ""
-  for (const line of lines) parseLine(line, parse, onEvent, onRecord)
+  for (const line of lines) await parseLine(line, parse, onEvent, onRecord)
   return tail
 }
 
 /** @param {string} line @param {RunWorkerOptions["parse"]} parse @param {RunWorkerOptions["onEvent"]} onEvent @param {RunWorkerOptions["onRecord"]} onRecord */
-function parseLine(line, parse, onEvent, onRecord) {
+async function parseLine(line, parse, onEvent, onRecord) {
   if (line.trim().length === 0) return
+  let record
+  try {
+    record = JSON.parse(line)
+  } catch {
+    await onEvent({type: "diagnostic", level: "warning", summary: "Worker emitted an unreadable event"})
+    return
+  }
+  await onRecord?.(record)
   let events
   try {
-    const record = JSON.parse(line)
-    onRecord?.(record)
     events = parse(record)
   } catch {
-    onEvent({type: "diagnostic", level: "warning", summary: "Worker emitted an unreadable event"})
+    await onEvent({type: "diagnostic", level: "warning", summary: "Worker emitted an unreadable event"})
     return
   }
-  for (const event of events) onEvent(event)
+  for (const event of events) await onEvent(event)
 }
 
 /** @param {NodeJS.Signals | null} signal */
@@ -153,6 +260,17 @@ function signalExitCode(signal) {
   return 128 + (osConstants.signals[signal] ?? 0)
 }
 
+/** @param {unknown} value @returns {value is number} */
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+}
+
+/** @param {ReturnType<typeof nodeSpawn>} child @param {number | null} processGroupPid @param {NodeJS.Signals} signal @param {(pid: number, signal: NodeJS.Signals) => boolean} killProcess */
+function signalChildTree(child, processGroupPid, signal, killProcess) {
+  if (processGroupPid !== null) return killProcess(-processGroupPid, signal)
+  return child.kill(signal)
+}
+
 /** @param {() => void} onInterrupt @param {() => void} onTerminate */
 function removeSignalHandlers(onInterrupt, onTerminate) {
   process.removeListener("SIGINT", onInterrupt)

package/src/telegram-ingress/command.js

@@ -3,6 +3,7 @@
 import {PROVIDERS} from "../providers/index.js"
 
 const COMMAND_PATTERN = /^\/code(?:@[A-Za-z0-9_]+)?\s+(codex|claude|opencode)\s+(\S[\s\S]*)$/u
+const EVIDENCE_PATTERN = /^\/evidence(?:@[A-Za-z0-9_]+)?\s+(evidence_[A-Za-z0-9_-]{43})\s+(bytes|lines)\s+(\d+):(\d+)$/u
 
 /**
  * @typedef {{provider: "codex" | "claude" | "opencode", prompt: string}} CodeCommand
@@ -27,3 +28,18 @@ export function parseCodeCommand(text) {
     prompt
   }
 }
+
+/** @param {string} text */
+export function parseEvidenceCommand(text) {
+  if (typeof text !== "string") return null
+  const match = EVIDENCE_PATTERN.exec(text)
+  if (!match) return null
+  const handle = match[1]
+  const selector = match[2]
+  const start = Number(match[3])
+  const limit = Number(match[4])
+  if (!handle || !Number.isSafeInteger(start) || !Number.isSafeInteger(limit) || limit <= 0) return null
+  if (selector === "bytes" && start >= 0) return {handle, bytes: {offset: start, limit}}
+  if (selector === "lines" && start > 0) return {handle, lines: {start, limit}}
+  return null
+}

package/src/telegram-ingress/config.js

@@ -3,6 +3,7 @@
 import {DEFAULT_TELEGRAM_REQUEST_TIMEOUT_MS, MAX_TIMER_DELAY_MS} from "../notifiers/fetch-transport.js"
 import {open as nodeOpen} from "node:fs/promises"
 import {constants as fsConstants} from "node:fs"
+import {isAbsolute, normalize, parse, relative} from "node:path"
 
 const TELEGRAM_ID_PATTERN = /^-?[1-9]\d*$/u
 const DEFAULT_PORT = 8787
@@ -10,6 +11,7 @@ const DEFAULT_HOST = "127.0.0.1"
 const DEFAULT_MAX_CONCURRENT_WORKERS = 4
 const DEFAULT_UPDATE_ID_CAPACITY = 10_000
 const DEFAULT_UPDATE_ID_TTL_MS = 86_400_000
+const DEFAULT_EVIDENCE_ROOT = "/var/lib/threadwire/evidence"
 export const MIN_WEBHOOK_SECRET_LENGTH = 32
 const MAX_SECRET_FILE_BYTES = 65_536
 const FILE_BACKED_SETTINGS = [
@@ -34,25 +36,90 @@ export async function resolveFileBackedSettings(source, names, operations = {})
     const file = environment[fileName]
     if (value !== undefined && file !== undefined) throw new Error(`${name} and ${fileName} must not both be set`)
     if (file === undefined) continue
-    let handle
     try {
-      handle = await (operations.open ?? nodeOpen)(file, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW)
-      const stats = await handle.stat()
-      if (!stats.isFile() || stats.size > MAX_SECRET_FILE_BYTES) throw new Error("invalid setting file")
-      const buffer = Buffer.alloc(MAX_SECRET_FILE_BYTES + 1)
-      const {bytesRead} = await handle.read(buffer, 0, buffer.length, 0)
-      if (bytesRead > MAX_SECRET_FILE_BYTES) throw new Error("invalid setting file")
-      environment[name] = buffer.subarray(0, bytesRead).toString("utf8").trim()
+      environment[name] = await readSecureSettingFile(file, operations)
     } catch {
       throw new Error(`${fileName} could not be read`)
-    } finally {
-      await handle?.close().catch(() => {})
     }
     delete environment[fileName]
   }
   return environment
 }
 
+/**
+ * Read one bounded regular secret file without following a final symlink.
+ * @param {string} file
+ * @param {{open?: (path: string, flags: number) => Promise<import("node:fs/promises").FileHandle>}} [operations]
+ */
+export async function readSecureSettingFile(file, operations = {}) {
+  if (!isAbsolute(file) || normalize(file) !== file || relative(parse(file).root, file).split("/").includes("..")) {
+    throw new Error("invalid setting file")
+  }
+  const openImpl = operations.open ?? nodeOpen
+  /** @type {import("node:fs/promises").FileHandle[]} */
+  const directories = []
+  let handle
+  try {
+    if (operations.open === undefined) {
+      let directory = await openImpl(parse(file).root, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW)
+      directories.push(directory)
+      for (const component of relative(parse(file).root, file).split("/").slice(0, -1)) {
+        const stats = await directory.stat()
+        if (!stats.isDirectory() || !trustedDirectory(stats)) throw new Error("invalid setting file")
+        directory = await openImpl(`/proc/self/fd/${directory.fd}/${component}`, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW)
+        directories.push(directory)
+      }
+      const parentStats = await directory.stat()
+      if (!parentStats.isDirectory() || !trustedDirectory(parentStats)) throw new Error("invalid setting file")
+      const name = relative(parse(file).root, file).split("/").at(-1)
+      handle = await openImpl(`/proc/self/fd/${directory.fd}/${name}`, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW)
+    } else {
+      handle = await openImpl(file, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW)
+    }
+    const stats = await handle.stat()
+    if (!stats.isFile() || stats.nlink !== 1 || stats.size > MAX_SECRET_FILE_BYTES || !trustedSecretFile(stats)) throw new Error("invalid setting file")
+    const buffer = Buffer.alloc(MAX_SECRET_FILE_BYTES + 1)
+    const {bytesRead} = await handle.read(buffer, 0, buffer.length, 0)
+    if (bytesRead > MAX_SECRET_FILE_BYTES) throw new Error("invalid setting file")
+    const value = buffer.subarray(0, bytesRead).toString("utf8").trim()
+    if (value.length === 0) throw new Error("invalid setting file")
+    return value
+  } finally {
+    await handle?.close().catch(() => {})
+    await Promise.all(directories.map((directory) => directory.close().catch(() => {})))
+  }
+}
+
+/** @param {import("node:fs").Stats} stats */
+function trustedDirectory(stats) {
+  const mode = stats.mode & 0o7777
+  return (stats.uid === 0 || stats.uid === process.getuid?.())
+    && ((mode & 0o022) === 0 || (stats.uid === 0 && (mode & 0o1000) !== 0))
+}
+
+/** @param {import("node:fs").Stats} stats */
+function trustedSecretFile(stats) {
+  const mode = stats.mode & 0o777
+  if (stats.uid === 0) return (mode & 0o222) === 0
+  return stats.uid === process.getuid?.() && (mode & 0o077) === 0
+}
+
+/** @param {NodeJS.ProcessEnv} environment */
+export async function collectEvidenceRedactions(environment) {
+  const redactions = []
+  for (const [key, value] of Object.entries(environment)) {
+    if (value === undefined) continue
+    if (/(?:TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)_FILE$/u.test(key)) {
+      if (value.length >= 4) redactions.push(value)
+      const secret = await readSecureSettingFile(value)
+      if (secret.length >= 4) redactions.push(secret)
+    } else if (/(?:TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)$/u.test(key) && value.length >= 4) {
+      redactions.push(value)
+    }
+  }
+  return redactions
+}
+
 /**
  * Resolve every supported ingress setting from a literal or bounded file.
  * @param {NodeJS.ProcessEnv} source
@@ -75,6 +142,7 @@ export async function resolveIngressEnvironment(source, operations = {}) {
  *   telegramRequestTimeoutMs: number,
  *   updateIdCapacity: number,
  *   updateIdTtlMs: number
+ *   evidenceRoot?: string
  * }} IngressConfig
  */
 
@@ -109,6 +177,7 @@ export function parseIngressConfig(environment) {
     "THREADWIRE_UPDATE_ID_TTL_MS",
     DEFAULT_UPDATE_ID_TTL_MS
   )
+  const evidenceRoot = parseEvidenceRoot(environment.THREADWIRE_EVIDENCE_ROOT)
   return {
     botToken,
     webhookSecret,
@@ -120,10 +189,18 @@ export function parseIngressConfig(environment) {
     toolMessages,
     telegramRequestTimeoutMs,
     updateIdCapacity,
-    updateIdTtlMs
+    updateIdTtlMs,
+    evidenceRoot
   }
 }
 
+/** @param {string | undefined} value */
+function parseEvidenceRoot(value) {
+  const root = value ?? DEFAULT_EVIDENCE_ROOT
+  if (!isAbsolute(root) || normalize(root) !== root) throw new Error("THREADWIRE_EVIDENCE_ROOT must be a normalized absolute path")
+  return root
+}
+
 /** @param {NodeJS.ProcessEnv} environment */
 export function parseTelegramRequestTimeoutMs(environment) {
   const timeoutMs = parsePositiveSafeInteger(
@@ -157,6 +234,13 @@ export function buildProviderEnvironment(source) {
 /** @param {string} key */
 function isIngressSecretKey(key) {
   if (FILE_BACKED_SETTINGS.some((name) => key === `${name}_FILE`)) return true
+  if (
+    key.startsWith("THREADWIRE_ISOLATED_RUNTIME_")
+    || key.startsWith("THREADWIRE_MODEL_BROKER_")
+    || key === "THREADWIRE_RELAY_WORKER_IMAGE"
+    || key === "THREADWIRE_ALLOWED_WORKTREE_ROOTS"
+    || key === "THREADWIRE_WORKTREE_VOLUME"
+  ) return true
   return key === "TELEGRAM_BOT_TOKEN" ||
     key === "THREADWIRE_TELEGRAM_BOT_TOKEN" ||
     key === "THREADWIRE_WEBHOOK_SECRET" ||
@@ -165,6 +249,7 @@ function isIngressSecretKey(key) {
     key === "THREADWIRE_WEBHOOK_PORT" ||
     key === "THREADWIRE_WEBHOOK_HOST" ||
     key === "THREADWIRE_MAX_CONCURRENT_WORKERS" ||
+    key === "THREADWIRE_EVIDENCE_ROOT" ||
     key === "THREADWIRE_TOOL_MESSAGES" ||
     key === "THREADWIRE_TELEGRAM_REQUEST_TIMEOUT_MS" ||
     key === "THREADWIRE_UPDATE_ID_CAPACITY" ||