@openclaw/plugin-inspector 0.3.24 → 0.3.26

package/src/process-profile.js

@@ -1,6 +1,147 @@
 import { spawn } from "node:child_process";
 import { performance } from "node:perf_hooks";
 
+const defaultTimeoutMs = 30_000;
+const defaultKillGraceMs = 1_000;
+const maxTimerMs = 2 ** 31 - 1;
+const killWaitMs = 1_000;
+
+// Shared by capture and profiling, not a package entrypoint. Each spawn owns
+// its POSIX process group; never signal the inspector's inherited group.
+export function startOwnedProcess(options, kind = "PROFILE") {
+  const env = options.env ?? process.env;
+  const { timeoutMs, killGraceMs, maxOutputBytes } = resolveProcessLimits(options, kind);
+  const stdout = createCappedCollector(maxOutputBytes);
+  const stderr = createCappedCollector(maxOutputBytes);
+  let timedOut = false;
+  let cancelled = options.signal?.aborted === true;
+  let error;
+  let closed = false;
+  let stopping = false;
+  let escalated = false;
+  let settled = false;
+  let code;
+  let exitSignal;
+  let timeoutId;
+  let forceKillId;
+  let closeDeadlineId;
+  let child;
+  let resolveResult;
+  const result = new Promise((resolve) => { resolveResult = resolve; });
+
+  const finish = () => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeoutId);
+    clearTimeout(forceKillId);
+    clearTimeout(closeDeadlineId);
+    options.signal?.removeEventListener("abort", cancel);
+    resolveResult({
+      exitCode: timedOut || cancelled || error ? 1 : (code ?? 1),
+      timedOut,
+      cancelled,
+      timeoutMs,
+      signal: exitSignal,
+      pid: child?.pid,
+      error,
+      stdout: stdout.text(),
+      stderr: stderr.text(),
+      outputTruncated: stdout.truncated || stderr.truncated,
+    });
+  };
+  const groupExists = () => {
+    if (!child?.pid) return false;
+    if (process.platform === "win32") return child.exitCode === null && child.signalCode === null;
+    try {
+      process.kill(-child.pid, 0);
+      return true;
+    } catch (cause) {
+      if (cause.code === "ESRCH") return false;
+      error ??= cause;
+      return true;
+    }
+  };
+  const signalGroup = (signal) => {
+    if (!child?.pid) return;
+    try {
+      if (process.platform === "win32") child.kill(signal);
+      else process.kill(-child.pid, signal);
+    } catch (cause) {
+      if (cause.code !== "ESRCH") error ??= cause;
+    }
+  };
+  const stop = () => {
+    if (stopping || settled) return;
+    stopping = true;
+    signalGroup("SIGTERM");
+    forceKillId = setTimeout(() => {
+      // The leader may already be reaped while its descendants hold the pipes.
+      signalGroup("SIGKILL");
+      escalated = true;
+      if (closed) {
+        finish();
+        return;
+      }
+      closeDeadlineId = setTimeout(() => {
+        error ??= new Error("Owned child stdio did not close after SIGKILL");
+        child?.stdout?.destroy();
+        child?.stderr?.destroy();
+        child?.stdin?.destroy();
+        child?.unref();
+        finish();
+      }, killWaitMs);
+    }, killGraceMs);
+  };
+  const cancel = () => {
+    cancelled = true;
+    stop();
+  };
+
+  if (cancelled) {
+    finish();
+    return { child, result };
+  }
+  try {
+    child = spawn(options.command, options.args ?? [], {
+      cwd: options.cwd,
+      env,
+      detached: process.platform !== "win32",
+      stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
+    });
+  } catch (cause) {
+    error = cause;
+    finish();
+    return { child, result };
+  }
+  child.stdout?.on("data", (chunk) => stdout.push(chunk));
+  child.stderr?.on("data", (chunk) => stderr.push(chunk));
+  const fail = (cause) => {
+    error ??= cause;
+    stop();
+  };
+  child.stdout?.on("error", fail);
+  child.stderr?.on("error", fail);
+  child.once("error", fail);
+  child.once("exit", () => {
+    // Clean descendants even after a successful leader exit or closed pipes.
+    if (groupExists()) stop();
+  });
+  child.once("close", (exitCode, signal) => {
+    closed = true;
+    code = exitCode;
+    exitSignal = signal;
+    if (!escalated && groupExists()) stop();
+    else finish();
+  });
+  timeoutId = setTimeout(() => {
+    timedOut = true;
+    stop();
+  }, timeoutMs);
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  if (options.signal?.aborted) cancel();
+  return { child, result };
+}
+
 export async function runProfiledProcess(options) {
   const start = performance.now();
   const heapStartMb = heapUsedMb();
@@ -10,129 +151,136 @@ export async function runProfiledProcess(options) {
   let statSampleCount = 0;
   let rssSampleCount = 0;
   let cpuSampleCount = 0;
-  const cpuSamples = [];
-  let pollInFlight = false;
-  const pendingStats = new Set();
-
-  const child = spawn(options.command, options.args ?? [], {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
-  });
-  const stdout = [];
-  const stderr = [];
-  child.stdout?.on("data", (chunk) => stdout.push(chunk));
-  child.stderr?.on("data", (chunk) => stderr.push(chunk));
-
-  const recordStats = (stats) => {
-    if (stats.rssAvailable || stats.cpuAvailable) {
-      statSampleCount += 1;
-    }
-    if (stats.rssAvailable) {
-      rssSampleCount += 1;
-    }
-    if (stats.cpuAvailable) {
-      cpuSampleCount += 1;
-    }
-    if (stats.rssAvailable && stats.rssKb > 0 && firstRssKb === 0) {
-      firstRssKb = stats.rssKb;
-    }
-    if (stats.rssAvailable) {
-      peakRssKb = Math.max(peakRssKb, stats.rssKb);
-    }
-    if (stats.cpuAvailable) {
-      peakCpuPercent = Math.max(peakCpuPercent, stats.cpuPercent);
-      cpuSamples.push(stats.cpuPercent);
-    }
-  };
-
+  let cpuTotal = 0;
+  let pendingStats;
+  let stopped = false;
+  const statsController = new AbortController();
+  const running = startOwnedProcess(options);
   const sampleStats = () => {
-    if (pollInFlight) {
-      return;
-    }
-    pollInFlight = true;
-    const pending = readProcessStats(child.pid)
-      .then(recordStats)
-      .finally(() => {
-        pollInFlight = false;
-        pendingStats.delete(pending);
-      });
-    pendingStats.add(pending);
+    if (pendingStats || stopped || !running.child?.pid) return;
+    pendingStats = readProcessStats(running.child.pid, options.env, statsController.signal)
+      .then((stats) => {
+        if (stopped) return;
+        if (stats.rssAvailable || stats.cpuAvailable) statSampleCount += 1;
+        if (stats.rssAvailable) {
+          rssSampleCount += 1;
+          if (stats.rssKb > 0 && firstRssKb === 0) firstRssKb = stats.rssKb;
+          peakRssKb = Math.max(peakRssKb, stats.rssKb);
+        }
+        if (stats.cpuAvailable) {
+          cpuSampleCount += 1;
+          peakCpuPercent = Math.max(peakCpuPercent, stats.cpuPercent);
+          cpuTotal += stats.cpuPercent;
+        }
+      })
+      .finally(() => { pendingStats = undefined; });
   };
-
+  const poll = setInterval(sampleStats, positiveLimit(options.pollMs, undefined, 25));
+  const stopSampling = () => {
+    stopped = true;
+    clearInterval(poll);
+    statsController.abort();
+  };
+  running.child?.once("exit", stopSampling);
+  running.child?.once("error", stopSampling);
   sampleStats();
-  const poll = setInterval(sampleStats, options.pollMs ?? 25);
-
-  const exitCode = await new Promise((resolve, reject) => {
-    child.on("error", (error) => {
-      clearInterval(poll);
-      reject(error);
-    });
-    child.on("exit", (code) => resolve(code ?? 1));
-  });
-  clearInterval(poll);
-  await Promise.allSettled([...pendingStats]);
-
-  const finalStats = await readProcessStats(child.pid);
-  recordStats(finalStats);
 
-  const wallMs = Math.round(performance.now() - start);
-  const averageCpuPercent =
-    cpuSamples.length > 0
-      ? cpuSamples.reduce((sum, value) => sum + value, 0) / cpuSamples.length
-      : 0;
-  const cpuPercentForEstimate =
-    options.roundAverageCpuPercent === true
+  try {
+    const outcome = await running.result;
+    stopSampling();
+    await pendingStats;
+    if (outcome.error) throw outcome.error;
+    const wallMs = Math.round(performance.now() - start);
+    const averageCpuPercent = cpuSampleCount > 0 ? cpuTotal / cpuSampleCount : 0;
+    const cpuPercentForEstimate = options.roundAverageCpuPercent === true
       ? Math.round(averageCpuPercent * 10) / 10
       : averageCpuPercent;
+    return {
+      wallMs,
+      peakRssMb: Math.round((peakRssKb / 1024) * 10) / 10,
+      rssDeltaMb: Math.round(((peakRssKb - firstRssKb) / 1024) * 10) / 10,
+      peakCpuPercent: Math.round(peakCpuPercent * 10) / 10,
+      cpuMsEstimate: Math.round((wallMs * cpuPercentForEstimate) / 100),
+      harnessHeapDeltaMb: Math.round((heapUsedMb() - heapStartMb) * 10) / 10,
+      statSampleCount,
+      rssSampleCount,
+      cpuSampleCount,
+      exitCode: outcome.exitCode,
+      timedOut: outcome.timedOut,
+      cancelled: outcome.cancelled,
+      pid: outcome.pid,
+      stdoutPreview: previewLines(outcome.stdout),
+      stderrPreview: previewLines(outcome.stderr),
+    };
+  } finally {
+    stopSampling();
+  }
+}
 
+export function resolveProcessLimits(options, kind = "PROFILE") {
+  const env = options.env ?? process.env;
+  const setting = (name) => env[`PLUGIN_INSPECTOR_${kind}_${name}`] ?? process.env[`PLUGIN_INSPECTOR_${kind}_${name}`];
   return {
-    wallMs,
-    peakRssMb: Math.round((peakRssKb / 1024) * 10) / 10,
-    rssDeltaMb: Math.round(((peakRssKb - firstRssKb) / 1024) * 10) / 10,
-    peakCpuPercent: Math.round(peakCpuPercent * 10) / 10,
-    cpuMsEstimate: Math.round((wallMs * cpuPercentForEstimate) / 100),
-    harnessHeapDeltaMb: Math.round((heapUsedMb() - heapStartMb) * 10) / 10,
-    statSampleCount,
-    rssSampleCount,
-    cpuSampleCount,
-    exitCode,
-    stdoutPreview: previewLines(stdout),
-    stderrPreview: previewLines(stderr),
+    timeoutMs: positiveLimit(options.timeoutMs, setting("TIMEOUT_MS"), defaultTimeoutMs),
+    killGraceMs: positiveLimit(options.killGraceMs, setting("KILL_GRACE_MS"), defaultKillGraceMs, 30_000),
+    maxOutputBytes: positiveLimit(options.maxOutputBytes, setting("MAX_OUTPUT_BYTES"), (kind === "CAPTURE" || kind === "PROBE" ? 10 : 1) * 1024 * 1024),
   };
 }
 
-async function readProcessStats(pid) {
-  if (!pid || process.platform === "win32") {
-    return { rssAvailable: false, rssKb: 0, cpuAvailable: false, cpuPercent: 0 };
-  }
-  return new Promise((resolve) => {
-    const ps = spawn("ps", ["-o", "rss=", "-o", "%cpu=", "-p", String(pid)], {
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    const chunks = [];
-    ps.stdout.on("data", (chunk) => chunks.push(chunk));
-    ps.on("error", () => resolve({ rssAvailable: false, rssKb: 0, cpuAvailable: false, cpuPercent: 0 }));
-    ps.on("exit", () => {
-      const [rssRaw, cpuRaw] = Buffer.concat(chunks).toString("utf8").trim().split(/\s+/);
-      const rssKb = Number.parseInt(rssRaw, 10);
-      const cpuPercent = Number.parseFloat(cpuRaw);
-      const rssAvailable = Number.isFinite(rssKb);
-      const cpuAvailable = Number.isFinite(cpuPercent);
-      resolve({
-        rssAvailable,
-        rssKb: rssAvailable ? rssKb : 0,
-        cpuAvailable,
-        cpuPercent: cpuAvailable ? cpuPercent : 0,
-      });
-    });
+function positiveLimit(option, env, fallback, max = maxTimerMs) {
+  const valid = (value) => Number.isFinite(value) && value > 0 && value <= max;
+  if (valid(option)) return Math.ceil(option);
+  const fromEnv = typeof env === "string" ? Number(env) : NaN;
+  return valid(fromEnv) ? Math.ceil(fromEnv) : fallback;
+}
+
+export function createCappedCollector(maxBytes) {
+  const chunks = [];
+  let size = 0;
+  let truncated = false;
+  return {
+    get truncated() { return truncated; },
+    push(chunk) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const length = Math.min(buffer.length, maxBytes - size);
+      if (length < buffer.length) truncated = true;
+      if (length === 0) return;
+      chunks.push(Buffer.from(buffer.subarray(0, length)));
+      size += length;
+    },
+    text: () => Buffer.concat(chunks, size).toString("utf8"),
+  };
+}
+
+async function readProcessStats(pid, env, signal) {
+  const unavailable = { rssAvailable: false, rssKb: 0, cpuAvailable: false, cpuPercent: 0 };
+  if (!pid || process.platform === "win32") return unavailable;
+  const { result } = startOwnedProcess({
+    command: "ps",
+    args: ["-o", "rss=", "-o", "%cpu=", "-p", String(pid)],
+    env,
+    signal,
+    timeoutMs: 250,
+    killGraceMs: 50,
+    maxOutputBytes: 4096,
   });
+  const outcome = await result;
+  if (outcome.exitCode !== 0 || outcome.outputTruncated) return unavailable;
+  const [rssRaw, cpuRaw] = outcome.stdout.trim().split(/\s+/);
+  const rssKb = Number.parseInt(rssRaw, 10);
+  const cpuPercent = Number.parseFloat(cpuRaw);
+  return {
+    rssAvailable: Number.isFinite(rssKb),
+    rssKb: Number.isFinite(rssKb) ? rssKb : 0,
+    cpuAvailable: Number.isFinite(cpuPercent),
+    cpuPercent: Number.isFinite(cpuPercent) ? cpuPercent : 0,
+  };
 }
 
 function heapUsedMb() {
   return Math.round((process.memoryUsage().heapUsed / 1024 / 1024) * 10) / 10;
 }
 
-function previewLines(chunks) {
-  return Buffer.concat(chunks).toString("utf8").trim().split("\n").slice(-2).join("\n");
+function previewLines(text) {
+  return text.trim().split("\n").slice(-2).join("\n");
 }

package/src/runtime-capture-report.js

@@ -12,6 +12,7 @@ export async function buildRuntimeCaptureReport(options = {}) {
   const results = [];
   for (const fixture of report.fixtures) {
     for (const target of captureTargets(fixture, rootDir)) {
+      options.signal?.throwIfAborted();
       results.push(await captureTarget(target, options));
     }
   }
@@ -117,6 +118,11 @@ async function captureTarget(target, options) {
       mockSdk: options.mockSdk !== false,
       apiOptions: options.apiOptions,
       env: options.env,
+      isolateCapture: options.isolateCapture,
+      timeoutMs: options.timeoutMs,
+      killGraceMs: options.killGraceMs,
+      maxOutputBytes: options.maxOutputBytes,
+      signal: options.signal,
     });
     return {
       fixture: target.fixture,

package/src/runtime-imports.js

@@ -0,0 +1,191 @@
+import * as nodeModule from "node:module";
+import { parse } from "acorn";
+import { analyze } from "eslint-scope";
+
+const literalModuleImport = /(?<![$\w.])(?:(?:const|let|var)\s+(?:\{[^{}]*\}|[$A-Z_a-z][$\w]*)\s*=\s*)?(?<kind>require|import)\s*\(\s*(?<quote>["'`])(?<specifier>[^"'`\\\r\n]+)\k<quote>/dg;
+
+export function collectRuntimeModuleImports(text) {
+  // Mark literal occurrences without interpreting quotes or regexes; the AST owns real calls.
+  const entries = [...text.matchAll(literalModuleImport)].map(moduleImportEntry).filter(Boolean);
+  if (entries.length === 0) return entries;
+  const { runtimeText, imports } = classifyRuntimeImports(text, entries);
+  let ast;
+  let scopes;
+  try {
+    // Accept both source modules and CommonJS wrappers without changing their runtime.
+    ast = parse(runtimeText, {
+      ecmaVersion: "latest", ranges: true, sourceType: "script",
+      allowAwaitOutsideFunction: true, allowReturnOutsideFunction: true, allowImportExportEverywhere: true,
+    });
+    scopes = analyze(ast, {
+      ecmaVersion: 2026,
+      sourceType: ast.body.some((node) => /^(?:Import|Export).*Declaration$/.test(node.type)) ? "module" : "commonjs",
+    });
+  } catch {
+    // Keep known imports if syntax is incomplete/unsupported; never guess namespace exports.
+    // Type erasure has already classified each occurrence, even when AST analysis fails.
+    const retained = new Set(imports.map(({ entry }) => entry.specifierStart));
+    return [...scanLiteralModuleImports(text)].filter((entry) => retained.has(entry.specifierStart))
+      .map((entry) => ({ ...entry, names: new Set() }));
+  }
+
+  const parents = new Map();
+  const nodes = [];
+  visit(ast);
+  function visit(node, parent) {
+    if (!node || typeof node.type !== "string") return;
+    parents.set(node, parent);
+    nodes.push(node);
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) value.forEach((child) => visit(child, node));
+      else if (value && typeof value === "object") visit(value, node);
+    }
+  }
+  const byMarker = new Map(imports.map(({ marker, entry }) => [marker, entry]));
+  const result = [];
+  for (const node of nodes) {
+    const source = node.type === "ImportExpression" ? node.source
+      : node.type === "CallExpression" && node.callee.type === "Identifier"
+        && node.callee.name === "require" && node.arguments.length === 1 ? node.arguments[0] : null;
+    const specifier = source?.type === "Literal" ? source.value
+      : source?.type === "TemplateLiteral" && source.expressions.length === 0 ? source.quasis[0].value.cooked : null;
+    const entry = byMarker.get(specifier);
+    if (!entry) continue;
+    const names = new Set();
+    result.push({ ...entry, names });
+    const access = parents.get(node);
+    const call = parents.get(access);
+    if (node.type === "ImportExpression" && access?.type === "MemberExpression" && access.object === node
+      && !access.computed && access.property.name === "then" && call?.type === "CallExpression" && call.callee === access) {
+      const callback = call.arguments[0];
+      if (callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression") {
+        collectBindingNames(callback.params[0], callback, names);
+      }
+    }
+    // Promise methods belong to import(), not its awaited module namespace.
+    const module = entry.kind === "require" ? node
+      : parents.get(node)?.type === "AwaitExpression" ? parents.get(node) : null;
+    if (!module) continue;
+    const parent = parents.get(module);
+    if (parent?.type === "MemberExpression" && parent.object === module && !parent.computed && parent.property.type === "Identifier") {
+      names.add(parent.property.name);
+    }
+    if (parent?.type === "VariableDeclarator" && parent.init === module) collectBindingNames(parent.id, parent, names);
+  }
+  return result.sort((a, b) => a.index - b.index);
+
+  function collectBindingNames(binding, owner, names) {
+    if (binding?.type === "ObjectPattern") {
+      for (const property of binding.properties) {
+        if (property.type === "Property" && !property.computed && property.key.type === "Identifier") {
+          names.add(property.key.name);
+        }
+      }
+    } else if (binding?.type === "Identifier") {
+      // Resolve references to this declaration, including closures but excluding shadowed names.
+      for (const variable of scopes.getDeclaredVariables(owner)) {
+        if (!variable.identifiers.includes(binding)) continue;
+        for (const reference of variable.references) {
+          const access = parents.get(reference.identifier);
+          if (access?.type === "MemberExpression" && access.object === reference.identifier && !access.computed && access.property.type === "Identifier") {
+            names.add(access.property.name);
+          }
+        }
+      }
+    }
+  }
+}
+
+function* scanLiteralModuleImports(text) {
+  const quotedOrComment = /\/\/[^\r\n]*|\/\*[\s\S]*?(?:\*\/|$)|"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'/;
+  const code = new RegExp(quotedOrComment.source + "|" + literalModuleImport.source + "|[`{}]", "dg");
+  const template = /\\[\s\S]|`|\$\{/g;
+  const templateDepths = [];
+  let inTemplateText = false;
+  let cursor = 0;
+  // Skip quoted/comment text, but scan executable template interpolations.
+  while (cursor < text.length) {
+    const pattern = inTemplateText ? template : code;
+    pattern.lastIndex = cursor;
+    const match = pattern.exec(text);
+    if (!match) break;
+    cursor = pattern.lastIndex;
+    if (inTemplateText) {
+      if (match[0] === "`") {
+        templateDepths.pop();
+        inTemplateText = false;
+      } else if (match[0] === "${") {
+        templateDepths[templateDepths.length - 1] = 1;
+        inTemplateText = false;
+      }
+      continue;
+    }
+    if (match[0] === "`") {
+      templateDepths.push(0);
+      inTemplateText = true;
+    } else if (templateDepths.length && match[0] === "{") {
+      templateDepths[templateDepths.length - 1] += 1;
+    } else if (templateDepths.length && match[0] === "}") {
+      inTemplateText = --templateDepths[templateDepths.length - 1] === 0;
+    }
+    const entry = moduleImportEntry(match);
+    if (entry) yield entry;
+  }
+}
+
+function moduleImportEntry(match) {
+  const groups = match.groups;
+  if (!groups?.specifier || (groups.quote === "`" && groups.specifier.includes("${"))) return null;
+  return {
+    specifier: groups.specifier,
+    specifierStart: match.indices.groups.specifier[0],
+    kind: groups.kind,
+    index: groups.kind === "import" ? match.indices.groups.kind[0] : match.index,
+  };
+}
+
+function classifyRuntimeImports(text, entries) {
+  const markedImports = entries.map((entry, index) => {
+    const { specifier, specifierStart } = entry;
+    return {
+      entry,
+      specifierStart,
+      specifierEnd: specifierStart + specifier.length,
+      marker: `${specifier}__plugin_inspector_runtime_import_${index}__`,
+    };
+  });
+  let markedText = text;
+  for (const markedImport of markedImports.toReversed()) {
+    markedText =
+      markedText.slice(0, markedImport.specifierStart) +
+      markedImport.marker +
+      markedText.slice(markedImport.specifierEnd);
+  }
+
+  let runtimeText = null;
+  try {
+    runtimeText = eraseTypeScript(markedText);
+  } catch {
+    // Unsupported or incomplete TypeScript cannot prove an import is type-only.
+  }
+  return {
+    runtimeText: runtimeText ?? markedText,
+    imports: runtimeText === null ? markedImports : markedImports.filter(({ marker }) => runtimeText.includes(marker)),
+  };
+}
+
+function eraseTypeScript(text) {
+  if (typeof nodeModule.stripTypeScriptTypes === "function") {
+    try {
+      return nodeModule.stripTypeScriptTypes(text, { mode: "transform" });
+    } catch (error) {
+      if (error?.code !== "ERR_INVALID_ARG_VALUE") throw error;
+      return nodeModule.stripTypeScriptTypes(text, { mode: "strip" });
+    }
+  }
+  if (typeof globalThis.Bun?.Transpiler === "function") {
+    const transpiler = new globalThis.Bun.Transpiler({ loader: "ts", target: "bun" });
+    return transpiler.transformSync(text);
+  }
+  return null;
+}

package/src/runtime-profile.js

@@ -333,6 +333,10 @@ async function profileCommand(command, options) {
     env: { ...process.env, ...options.env, ...command.env },
     stdio: ["ignore", "pipe", "pipe"],
     roundAverageCpuPercent: true,
+    timeoutMs: command.timeoutMs ?? options.timeoutMs,
+    maxOutputBytes: command.maxOutputBytes ?? options.maxOutputBytes,
+    killGraceMs: command.killGraceMs ?? options.killGraceMs,
+    signal: options.signal,
   });
 }
 

package/src/runtime-reconciliation.js

@@ -81,12 +81,6 @@ function expectedRuntimeCaptureKeys(finding) {
   if (finding.code === "runtime-tool-capture") {
     return ["registration:registerTool"];
   }
-  if (finding.code === "conversation-access-hook") {
-    return names.map((name) => `hook:${name}`);
-  }
-  if (finding.code === "before-tool-call-probe") {
-    return ["hook:before_tool_call"];
-  }
   return [];
 }