@abot-ai/runtime 1.4.0 → 1.5.0

package/plugins/exec/src/index.cjs

@@ -177,6 +177,7 @@ function enforcePluginResultByteBudget(result) {
 function failureResult(input) {
   return enforcePluginResultByteBudget({
     ok: false,
+    ...input.media !== void 0 ? { media: input.media } : {},
     output: input.output ?? input.message,
     producedNewInformation: false,
     ...input.progress !== void 0 ? { progress: input.progress } : {},
@@ -201,29 +202,8 @@ function failureFromError(error, options) {
   });
 }
 
-// plugins/exec/source/errors.ts
-var ExecPluginError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "ExecPluginError";
-    this.code = code;
-  }
-};
-function execFailureFromError(error, operation) {
-  if (error instanceof ExecPluginError) {
-    return failureResult({
-      errorCode: error.code,
-      message: error.message,
-      output: `${operation} failed: ${error.message}`
-    });
-  }
-  return failureFromError(error, {
-    fallbackCode: `${operation}_failed`,
-    fallbackMessage: `${operation} failed without a safe diagnostic.`,
-    operation
-  });
-}
+// src/capabilities/tool-media.ts
+var TOOL_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
 
 // plugins/exec/source/filesystem-observer.ts
 var import_node_crypto = require("node:crypto");
@@ -495,6 +475,329 @@ function diffExecFilesystemSnapshots(before, after) {
   });
 }
 
+// plugins/exec/source/result-presentation.ts
+function streamDisplay(snapshot) {
+  if (snapshot.text) return snapshot.text;
+  return snapshot.sawOutput ? "(no new output; earlier output was already returned)" : "(empty)";
+}
+function renderedOutput(lines, outputMaxChars) {
+  const bounded = boundText(lines.join("\n"), {
+    maxChars: outputMaxChars,
+    marker: "\n[exec output truncated]"
+  });
+  return Object.freeze({ output: bounded.text, metadata: bounded.metadata });
+}
+function outputBoundsData(snapshot, rendered, maxChars) {
+  return Object.freeze({
+    maxChars,
+    stdout: snapshot.stdout.metadata,
+    stderr: snapshot.stderr.metadata,
+    rendered
+  });
+}
+function runningResult(snapshot, execution) {
+  const nextCursor = snapshot.nextCursor ?? 1;
+  const rendered = renderedOutput(
+    [
+      `Command: ${execution.commandPreview}`,
+      `CWD: ${execution.cwd.logicalPath}`,
+      "Process status: running",
+      `Process ID: ${snapshot.processId}`,
+      `Next cursor: ${nextCursor}`,
+      "STDOUT since the previous observation:",
+      streamDisplay(snapshot.stdout),
+      "STDERR since the previous observation:",
+      streamDisplay(snapshot.stderr),
+      "Continue this exact process with exec_wait; do not run the command again."
+    ],
+    execution.outputMaxChars
+  );
+  return failureResult({
+    errorCode: "exec_process_running",
+    message: "The command is still running. Continue it with exec_wait using the returned process ID and cursor.",
+    output: rendered.output,
+    stdout: snapshot.stdout.text,
+    stderr: snapshot.stderr.text,
+    data: {
+      processId: snapshot.processId,
+      processStatus: "running",
+      nextCursor,
+      outputBounds: outputBoundsData(
+        snapshot,
+        rendered.metadata,
+        execution.outputMaxChars
+      ),
+      observationMeta: {
+        kind: "volatile_external",
+        carryPolicy: "never"
+      }
+    }
+  });
+}
+async function captureFilesystemDelta(execution) {
+  if (!execution.filesystemStateBefore) return null;
+  try {
+    const after = await captureExecFilesystemSnapshot(
+      execution.cwd.absolutePath,
+      execution.cwd.logicalPath
+    );
+    return diffExecFilesystemSnapshots(execution.filesystemStateBefore, after);
+  } catch {
+    return null;
+  }
+}
+function projectExecFilesystemEvidence(delta, logicalRoot) {
+  const effects = delta.actions.map(renderExecFilesystemEffect);
+  const omittedEffectCount = Math.max(
+    0,
+    delta.changedEntryCount - effects.length
+  );
+  const omittedEffectLine = omittedEffectCount > 0 ? `- ${omittedEffectCount} additional changed ${omittedEffectCount === 1 ? "entry" : "entries"} omitted by the ${delta.observation.actionLimit}-effect projection limit.` : void 0;
+  const outputLines = Object.freeze([
+    `Filesystem changes observed: ${delta.changedEntryCount}${delta.observation.complete ? "" : " (bounded observation)"}`,
+    "Filesystem effects observed:",
+    ...effects,
+    ...omittedEffectLine ? [omittedEffectLine] : []
+  ]);
+  return Object.freeze({
+    outputLines,
+    mutationGrounding: [
+      "Observed post-command filesystem effects (settled tool evidence; not command intent, semantic verification, or complete artifact content):",
+      `- observation root: ${logicalRoot}`,
+      `- observation complete: ${delta.observation.complete}`,
+      `- changed entries: ${delta.changedEntryCount}`,
+      `- listed effects: ${effects.length}`,
+      `- effects truncated: ${delta.observation.actionsTruncated}`,
+      "Effects:",
+      ...effects,
+      ...omittedEffectLine ? [omittedEffectLine] : []
+    ].join("\n")
+  });
+}
+function renderExecFilesystemEffect(action) {
+  const target = action.target ? `: ${action.target}` : "";
+  const state = action.details === "exec_filesystem_created" ? "created" : action.details === "exec_filesystem_modified" ? "modified" : action.details === "exec_filesystem_removed" ? "removed" : void 0;
+  return `- ${action.type}${target}${state ? ` (${state})` : ""}`;
+}
+async function finalizeExecResult(params) {
+  const { snapshot, execution } = params;
+  const exitCode = snapshot.exitCode ?? -1;
+  const cancellationIsSuccess = params.cancellationIsSuccess === true && snapshot.terminationReason === "cancelled";
+  const filesystemDelta = await captureFilesystemDelta(execution);
+  const observedStateChange = filesystemDelta?.observedStateChange === true;
+  const filesystemEvidence = observedStateChange && filesystemDelta ? projectExecFilesystemEvidence(
+    filesystemDelta,
+    execution.cwd.logicalPath
+  ) : null;
+  const commandHasData = snapshot.stdout.sawOutput || snapshot.stderr.sawOutput;
+  const ok = exitCode === 0 || cancellationIsSuccess;
+  const inconclusiveSuccess = exitCode === 0 && !commandHasData && !observedStateChange;
+  const producedNewInformation = observedStateChange || cancellationIsSuccess || ok && commandHasData;
+  const actions = filesystemDelta?.actions ?? [];
+  const resultSummary = cancellationIsSuccess ? "Result summary: the running command was cancelled." : inconclusiveSuccess ? "Result summary: the command completed without observable output or filesystem change. Inspect a concrete target or use a dedicated creation capability." : "";
+  const rendered = renderedOutput(
+    [
+      `Command: ${execution.commandPreview}`,
+      `CWD: ${execution.cwd.logicalPath}`,
+      `Process ID: ${snapshot.processId}`,
+      `Process status: ${snapshot.terminationReason ?? "completed"}`,
+      `Exit code: ${exitCode}`,
+      ...filesystemEvidence ? filesystemEvidence.outputLines : [],
+      "STDOUT:",
+      streamDisplay(snapshot.stdout),
+      "STDERR:",
+      streamDisplay(snapshot.stderr),
+      ...resultSummary ? [resultSummary] : []
+    ],
+    execution.outputMaxChars
+  );
+  const processStatus = snapshot.terminationReason ?? "completed";
+  const data = {
+    ...commandHasData ? { hasData: true } : {},
+    ...observedStateChange ? { mutationEvidence: true } : {},
+    ...filesystemEvidence ? { mutationGrounding: filesystemEvidence.mutationGrounding } : {},
+    processId: snapshot.processId,
+    processStatus,
+    outputBounds: outputBoundsData(
+      snapshot,
+      rendered.metadata,
+      execution.outputMaxChars
+    ),
+    ...filesystemDelta ? { filesystemObservation: filesystemDelta.observation } : { filesystemObservation: { available: false } },
+    observationMeta: {
+      kind: "volatile_external",
+      carryPolicy: "never"
+    }
+  };
+  const common = {
+    output: rendered.output,
+    progress: observedStateChange || cancellationIsSuccess,
+    producedNewInformation,
+    actions: [...actions],
+    exitCode,
+    stdout: snapshot.stdout.text,
+    stderr: snapshot.stderr.text,
+    data
+  };
+  if (ok && (!inconclusiveSuccess || cancellationIsSuccess)) {
+    return enforcePluginResultByteBudget({ ok: true, ...common });
+  }
+  const errorCode = inconclusiveSuccess ? "no_observable_result" : snapshot.terminationReason === "aborted" ? "exec_aborted" : snapshot.terminationReason === "spawn_failed" ? "exec_spawn_failed" : snapshot.terminationReason === "idle_timeout" ? "exec_idle_timeout" : snapshot.terminationReason === "hard_timeout" ? "exec_hard_timeout" : "non_zero_exit";
+  const error = inconclusiveSuccess ? resultSummary : errorCode === "exec_aborted" ? "The exec request was aborted." : errorCode === "exec_spawn_failed" ? "The runtime could not start the configured non-interactive shell." : errorCode === "exec_idle_timeout" ? `The command produced no output for ${execution.idleTimeoutMs}ms.` : errorCode === "exec_hard_timeout" ? `The command exceeded the ${execution.hardTimeoutMs}ms hard timeout.` : `The command exited with code ${exitCode}.`;
+  return enforcePluginResultByteBudget({
+    ok: false,
+    ...common,
+    error,
+    errorCode
+  });
+}
+
+// plugins/exec/source/errors.ts
+var ExecPluginError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ExecPluginError";
+    this.code = code;
+  }
+};
+function execFailureFromError(error, operation) {
+  if (error instanceof ExecPluginError) {
+    return failureResult({
+      errorCode: error.code,
+      message: error.message,
+      output: `${operation} failed: ${error.message}`
+    });
+  }
+  return failureFromError(error, {
+    fallbackCode: `${operation}_failed`,
+    fallbackMessage: `${operation} failed without a safe diagnostic.`,
+    operation
+  });
+}
+
+// plugins/exec/source/request-resources.ts
+var ExecRequestResources = class {
+  constructor(manager, pending, preparation) {
+    this.manager = manager;
+    this.pending = pending;
+    const state = preparation?.requestState;
+    if (!state) return;
+    const saved = state.read("exec.terminal.v1");
+    if (saved !== void 0) this.restore(saved);
+    state.register("exec.terminal.v1", {
+      snapshot: () => this.snapshot(),
+      dispose: () => this.dispose()
+    });
+  }
+  manager;
+  pending;
+  owned = /* @__PURE__ */ new Map();
+  restored = /* @__PURE__ */ new Map();
+  started(processId, scope, settled, context) {
+    this.owned.set(processId, scope);
+    context?.requestWork?.trackUntil(settled);
+  }
+  forget(processId) {
+    this.owned.delete(processId);
+    this.restored.delete(processId);
+  }
+  terminal(processId, scope, cursor) {
+    const entry = this.restored.get(processId);
+    if (!entry) return void 0;
+    if (entry.scope !== scope)
+      throw new ExecPluginError(
+        "unknown_exec_process",
+        "The exec process belongs to a different session."
+      );
+    if (cursor !== void 0 && cursor !== entry.cursor)
+      throw new ExecPluginError(
+        "stale_exec_process_cursor",
+        "The saved exec cursor is stale."
+      );
+    this.restored.delete(processId);
+    return structuredClone(entry.snapshot);
+  }
+  snapshot() {
+    const executions = [...this.restored.values()];
+    for (const [processId, scope] of this.owned) {
+      const execution = this.pending.get(processId);
+      if (!execution) continue;
+      const terminal = this.manager.snapshotSettled(processId, scope);
+      const before = execution.filesystemStateBefore;
+      executions.push({
+        processId,
+        scope,
+        ...terminal,
+        execution: {
+          ...execution,
+          filesystemStateBefore: before ? { ...before, entries: [...before.entries] } : null
+        }
+      });
+    }
+    return { kind: "exec_terminal_state_v1", executions };
+  }
+  restore(value) {
+    if (!isRecord(value) || value.kind !== "exec_terminal_state_v1" || !Array.isArray(value.executions))
+      throw invalid();
+    for (const entry of value.executions) {
+      if (!isSavedExecution(entry) || this.restored.has(entry.processId))
+        throw invalid();
+      const before = entry.execution.filesystemStateBefore;
+      this.restored.set(entry.processId, structuredClone(entry));
+      this.pending.set(entry.processId, {
+        ...structuredClone(entry.execution),
+        filesystemStateBefore: before ? { ...before, entries: new Map(before.entries) } : null
+      });
+    }
+  }
+  async dispose() {
+    for (const [processId, scope] of this.owned) {
+      try {
+        await this.manager.cancel({ processId, scope });
+      } catch {
+      }
+      try {
+        await this.manager.release(processId, scope);
+      } catch {
+      }
+      this.pending.delete(processId);
+    }
+    for (const id of this.restored.keys()) this.pending.delete(id);
+    this.owned.clear();
+    this.restored.clear();
+  }
+};
+function isSavedExecution(value) {
+  if (!isRecord(value) || typeof value.processId !== "string" || typeof value.scope !== "string" || !Number.isSafeInteger(value.cursor) || value.cursor < 1 || !isRecord(value.snapshot) || value.snapshot.processId !== value.processId || value.snapshot.status !== "settled" || !isStream(value.snapshot.stdout) || !isStream(value.snapshot.stderr) || !Number.isFinite(value.snapshot.elapsedMs) || !isRecord(value.execution) || typeof value.execution.commandPreview !== "string" || !isRecord(value.execution.cwd) || typeof value.execution.cwd.absolutePath !== "string" || typeof value.execution.cwd.logicalPath !== "string")
+    return false;
+  if (![
+    value.execution.hardTimeoutMs,
+    value.execution.idleTimeoutMs,
+    value.execution.outputMaxChars
+  ].every(Number.isFinite))
+    return false;
+  const before = value.execution.filesystemStateBefore;
+  return before === null || isRecord(before) && typeof before.absoluteRoot === "string" && typeof before.logicalRoot === "string" && typeof before.rootExists === "boolean" && typeof before.complete === "boolean" && Array.isArray(before.entries) && before.entries.every(
+    (entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && isRecord(entry[1]) && typeof entry[1].kind === "string" && [entry[1].mode, entry[1].size, entry[1].mtimeMs].every(
+      Number.isFinite
+    )
+  );
+}
+function isStream(value) {
+  return isRecord(value) && typeof value.text === "string" && typeof value.sawOutput === "boolean" && isRecord(value.metadata) && typeof value.metadata.truncated === "boolean" && [
+    value.metadata.originalChars,
+    value.metadata.returnedChars,
+    value.metadata.omittedChars
+  ].every(Number.isFinite);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function invalid() {
+  return new Error("exec_terminal_snapshot_invalid");
+}
+
 // plugins/exec/source/paths.ts
 var import_promises2 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
@@ -573,33 +876,7 @@ var import_node_child_process = require("node:child_process");
 var import_node_crypto2 = require("node:crypto");
 var import_node_string_decoder = require("node:string_decoder");
 
-// plugins/exec/source/shell-platform.ts
-var import_node_fs2 = require("node:fs");
-var import_promises3 = require("node:fs/promises");
-var EXEC_SHELL = "/bin/bash";
-function isSupportedExecPlatform(platform) {
-  return platform === "linux" || platform === "darwin";
-}
-async function assertSupportedShell(platform = process.platform) {
-  if (!isSupportedExecPlatform(platform)) {
-    throw new ExecPluginError(
-      "exec_platform_unsupported",
-      "The exec plugin requires Linux or macOS and executable /bin/bash."
-    );
-  }
-  try {
-    await (0, import_promises3.access)(EXEC_SHELL, import_node_fs2.constants.X_OK);
-  } catch {
-    throw new ExecPluginError(
-      "exec_shell_unavailable",
-      "The exec plugin cannot start because executable /bin/bash is unavailable."
-    );
-  }
-}
-
-// plugins/exec/source/process-manager.ts
-var COMPLETED_PROCESS_RETENTION_MS = 5 * 6e4;
-var MAX_ACTIVE_PROCESSES_PER_SCOPE = 4;
+// plugins/exec/source/process-output-buffer.ts
 var CappedTextBuffer = class {
   constructor(maxChars) {
     this.maxChars = maxChars;
@@ -618,13 +895,10 @@ var CappedTextBuffer = class {
     this.text += safeChunk.slice(0, available);
     this.omittedChars += Math.max(safeChunk.length - available, 0);
   }
-  consume() {
+  peek() {
     const text = this.text;
     const originalChars = this.originalChars;
     const omittedChars = this.omittedChars;
-    this.text = "";
-    this.originalChars = 0;
-    this.omittedChars = 0;
     return Object.freeze({
       text,
       sawOutput: this.sawOutput,
@@ -636,7 +910,42 @@ var CappedTextBuffer = class {
       })
     });
   }
+  consume() {
+    const result = this.peek();
+    this.text = "";
+    this.originalChars = 0;
+    this.omittedChars = 0;
+    return result;
+  }
 };
+
+// plugins/exec/source/shell-platform.ts
+var import_node_fs2 = require("node:fs");
+var import_promises3 = require("node:fs/promises");
+var EXEC_SHELL = "/bin/bash";
+function isSupportedExecPlatform(platform) {
+  return platform === "linux" || platform === "darwin";
+}
+async function assertSupportedShell(platform = process.platform) {
+  if (!isSupportedExecPlatform(platform)) {
+    throw new ExecPluginError(
+      "exec_platform_unsupported",
+      "The exec plugin requires Linux or macOS and executable /bin/bash."
+    );
+  }
+  try {
+    await (0, import_promises3.access)(EXEC_SHELL, import_node_fs2.constants.X_OK);
+  } catch {
+    throw new ExecPluginError(
+      "exec_shell_unavailable",
+      "The exec plugin cannot start because executable /bin/bash is unavailable."
+    );
+  }
+}
+
+// plugins/exec/source/process-manager.ts
+var COMPLETED_PROCESS_RETENTION_MS = 5 * 6e4;
+var MAX_ACTIVE_PROCESSES_PER_SCOPE = 4;
 function createExecProcessManager() {
   const processes = /* @__PURE__ */ new Map();
   const unknownProcess = () => new ExecPluginError(
@@ -791,6 +1100,7 @@ function createExecProcessManager() {
         ...params.onDisposed ? { onDisposed: params.onDisposed } : {}
       };
       processes.set(managed.processId, managed);
+      params.onStarted?.(managed.processId, managed.settlePromise);
       const observe = (stream, chunk) => {
         if (managed.settled || !chunk) return;
         if (stream === "stdout") managed.stdout.append(chunk);
@@ -870,6 +1180,23 @@ function createExecProcessManager() {
         return consumeSnapshot(managed);
       });
     },
+    snapshotSettled(processId, scope) {
+      const managed = getScopedProcess(processId, scope);
+      if (!managed.settled || managed.waitInFlight || managed.terminalSnapshotClaimed)
+        throw new Error("exec_snapshot_not_quiescent");
+      return Object.freeze({
+        cursor: managed.cursor,
+        snapshot: Object.freeze({
+          processId,
+          status: "settled",
+          ...managed.exitCode === void 0 ? {} : { exitCode: managed.exitCode },
+          stdout: managed.stdout.peek(),
+          stderr: managed.stderr.peek(),
+          ...managed.terminationReason ? { terminationReason: managed.terminationReason } : {},
+          elapsedMs: Date.now() - managed.startedAt
+        })
+      });
+    },
     async release(processId, scope) {
       const managed = processes.get(processId);
       if (!managed) return;
@@ -947,12 +1274,12 @@ function isInvalidExecParameter(name, value) {
 function createExecAdapter() {
   return {
     validateCall(input) {
-      const invalid = ["command", "cwd"].filter(
+      const invalid2 = ["command", "cwd"].filter(
         (name) => isInvalidExecParameter(name, input.params[name])
       );
-      if (invalid.length === 0) return null;
+      if (invalid2.length === 0) return null;
       return {
-        error: `invalid params for exec: invalid ${invalid.join(", ")}`,
+        error: `invalid params for exec: invalid ${invalid2.join(", ")}`,
         repairHint: "Provide one command without NUL characters and one explicit existing cwd."
       };
     }
@@ -965,189 +1292,20 @@ function processScope(context) {
   const sessionId = context?.sharedState?.currentSessionId?.trim();
   return sessionId || "anonymous";
 }
-function streamDisplay(snapshot) {
-  if (snapshot.text) return snapshot.text;
-  return snapshot.sawOutput ? "(no new output; earlier output was already returned)" : "(empty)";
-}
-function renderedOutput(lines, outputMaxChars) {
-  const bounded = boundText(lines.join("\n"), {
-    maxChars: outputMaxChars,
-    marker: "\n[exec output truncated]"
-  });
-  return Object.freeze({ output: bounded.text, metadata: bounded.metadata });
-}
-function outputBoundsData(snapshot, rendered, maxChars) {
-  return Object.freeze({
-    maxChars,
-    stdout: snapshot.stdout.metadata,
-    stderr: snapshot.stderr.metadata,
-    rendered
-  });
-}
-function runningResult(snapshot, execution) {
-  const nextCursor = snapshot.nextCursor ?? 1;
-  const rendered = renderedOutput(
-    [
-      `Command: ${execution.commandPreview}`,
-      `CWD: ${execution.cwd.logicalPath}`,
-      "Process status: running",
-      `Process ID: ${snapshot.processId}`,
-      `Next cursor: ${nextCursor}`,
-      "STDOUT since the previous observation:",
-      streamDisplay(snapshot.stdout),
-      "STDERR since the previous observation:",
-      streamDisplay(snapshot.stderr),
-      "Continue this exact process with exec_wait; do not run the command again."
-    ],
-    execution.outputMaxChars
-  );
-  return failureResult({
-    errorCode: "exec_process_running",
-    message: "The command is still running. Continue it with exec_wait using the returned process ID and cursor.",
-    output: rendered.output,
-    stdout: snapshot.stdout.text,
-    stderr: snapshot.stderr.text,
-    data: {
-      processId: snapshot.processId,
-      processStatus: "running",
-      nextCursor,
-      outputBounds: outputBoundsData(
-        snapshot,
-        rendered.metadata,
-        execution.outputMaxChars
-      ),
-      observationMeta: {
-        kind: "volatile_external",
-        carryPolicy: "never"
-      }
-    }
-  });
-}
-async function captureFilesystemDelta(execution) {
-  if (!execution.filesystemStateBefore) return null;
-  try {
-    const after = await captureExecFilesystemSnapshot(
-      execution.cwd.absolutePath,
-      execution.cwd.logicalPath
-    );
-    return diffExecFilesystemSnapshots(execution.filesystemStateBefore, after);
-  } catch {
-    return null;
-  }
-}
-function projectExecFilesystemEvidence(delta, logicalRoot) {
-  const effects = delta.actions.map(renderExecFilesystemEffect);
-  const omittedEffectCount = Math.max(
-    0,
-    delta.changedEntryCount - effects.length
-  );
-  const omittedEffectLine = omittedEffectCount > 0 ? `- ${omittedEffectCount} additional changed ${omittedEffectCount === 1 ? "entry" : "entries"} omitted by the ${delta.observation.actionLimit}-effect projection limit.` : void 0;
-  const outputLines = Object.freeze([
-    `Filesystem changes observed: ${delta.changedEntryCount}${delta.observation.complete ? "" : " (bounded observation)"}`,
-    "Filesystem effects observed:",
-    ...effects,
-    ...omittedEffectLine ? [omittedEffectLine] : []
-  ]);
-  return Object.freeze({
-    outputLines,
-    mutationGrounding: [
-      "Observed post-command filesystem effects (settled tool evidence; not command intent, semantic verification, or complete artifact content):",
-      `- observation root: ${logicalRoot}`,
-      `- observation complete: ${delta.observation.complete}`,
-      `- changed entries: ${delta.changedEntryCount}`,
-      `- listed effects: ${effects.length}`,
-      `- effects truncated: ${delta.observation.actionsTruncated}`,
-      "Effects:",
-      ...effects,
-      ...omittedEffectLine ? [omittedEffectLine] : []
-    ].join("\n")
-  });
-}
-function renderExecFilesystemEffect(action) {
-  const target = action.target ? `: ${action.target}` : "";
-  const state = action.details === "exec_filesystem_created" ? "created" : action.details === "exec_filesystem_modified" ? "modified" : action.details === "exec_filesystem_removed" ? "removed" : void 0;
-  return `- ${action.type}${target}${state ? ` (${state})` : ""}`;
-}
-async function finalizeExecResult(params) {
-  const { snapshot, execution } = params;
-  const exitCode = snapshot.exitCode ?? -1;
-  const cancellationIsSuccess = params.cancellationIsSuccess === true && snapshot.terminationReason === "cancelled";
-  const filesystemDelta = await captureFilesystemDelta(execution);
-  const observedStateChange = filesystemDelta?.observedStateChange === true;
-  const filesystemEvidence = observedStateChange && filesystemDelta ? projectExecFilesystemEvidence(
-    filesystemDelta,
-    execution.cwd.logicalPath
-  ) : null;
-  const commandHasData = snapshot.stdout.sawOutput || snapshot.stderr.sawOutput;
-  const ok = exitCode === 0 || cancellationIsSuccess;
-  const inconclusiveSuccess = exitCode === 0 && !commandHasData && !observedStateChange;
-  const producedNewInformation = observedStateChange || cancellationIsSuccess || ok && commandHasData;
-  const actions = filesystemDelta?.actions ?? [];
-  const resultSummary = cancellationIsSuccess ? "Result summary: the running command was cancelled." : inconclusiveSuccess ? "Result summary: the command completed without observable output or filesystem change. Inspect a concrete target or use a dedicated creation capability." : "";
-  const rendered = renderedOutput(
-    [
-      `Command: ${execution.commandPreview}`,
-      `CWD: ${execution.cwd.logicalPath}`,
-      `Process ID: ${snapshot.processId}`,
-      `Process status: ${snapshot.terminationReason ?? "completed"}`,
-      `Exit code: ${exitCode}`,
-      ...filesystemEvidence ? filesystemEvidence.outputLines : [],
-      "STDOUT:",
-      streamDisplay(snapshot.stdout),
-      "STDERR:",
-      streamDisplay(snapshot.stderr),
-      ...resultSummary ? [resultSummary] : []
-    ],
-    execution.outputMaxChars
-  );
-  const processStatus = snapshot.terminationReason ?? "completed";
-  const data = {
-    ...commandHasData ? { hasData: true } : {},
-    ...observedStateChange ? { mutationEvidence: true } : {},
-    ...filesystemEvidence ? { mutationGrounding: filesystemEvidence.mutationGrounding } : {},
-    processId: snapshot.processId,
-    processStatus,
-    outputBounds: outputBoundsData(
-      snapshot,
-      rendered.metadata,
-      execution.outputMaxChars
-    ),
-    ...filesystemDelta ? { filesystemObservation: filesystemDelta.observation } : { filesystemObservation: { available: false } },
-    observationMeta: {
-      kind: "volatile_external",
-      carryPolicy: "never"
-    }
-  };
-  const common = {
-    output: rendered.output,
-    progress: observedStateChange || cancellationIsSuccess,
-    producedNewInformation,
-    actions: [...actions],
-    exitCode,
-    stdout: snapshot.stdout.text,
-    stderr: snapshot.stderr.text,
-    data
-  };
-  if (ok && (!inconclusiveSuccess || cancellationIsSuccess)) {
-    return enforcePluginResultByteBudget({ ok: true, ...common });
-  }
-  const errorCode = inconclusiveSuccess ? "no_observable_result" : snapshot.terminationReason === "aborted" ? "exec_aborted" : snapshot.terminationReason === "spawn_failed" ? "exec_spawn_failed" : snapshot.terminationReason === "idle_timeout" ? "exec_idle_timeout" : snapshot.terminationReason === "hard_timeout" ? "exec_hard_timeout" : "non_zero_exit";
-  const error = inconclusiveSuccess ? resultSummary : errorCode === "exec_aborted" ? "The exec request was aborted." : errorCode === "exec_spawn_failed" ? "The runtime could not start the configured non-interactive shell." : errorCode === "exec_idle_timeout" ? `The command produced no output for ${execution.idleTimeoutMs}ms.` : errorCode === "exec_hard_timeout" ? `The command exceeded the ${execution.hardTimeoutMs}ms hard timeout.` : `The command exited with code ${exitCode}.`;
-  return enforcePluginResultByteBudget({
-    ok: false,
-    ...common,
-    error,
-    errorCode
-  });
-}
-function createExecHandlers(pluginContext, settings) {
+function createExecHandlers(pluginContext, settings, preparation) {
   const processManager = createExecProcessManager();
   const pendingExecutions = /* @__PURE__ */ new Map();
+  const requestResources = new ExecRequestResources(
+    processManager,
+    pendingExecutions,
+    preparation
+  );
   const finalizeAndRelease = async (params) => {
     try {
       return await finalizeExecResult(params);
     } finally {
       pendingExecutions.delete(params.snapshot.processId);
+      requestResources.forget(params.snapshot.processId);
       await processManager.release(params.snapshot.processId, params.scope);
     }
   };
@@ -1185,7 +1343,11 @@ function createExecHandlers(pluginContext, settings) {
         idleTimeoutMs: execution.idleTimeoutMs,
         hardTimeoutMs: execution.hardTimeoutMs,
         ...context?.abortSignal ? { abortSignal: context.abortSignal } : {},
-        onDisposed: (processId) => pendingExecutions.delete(processId)
+        onDisposed: (processId) => {
+          pendingExecutions.delete(processId);
+          requestResources.forget(processId);
+        },
+        onStarted: (processId, settled) => requestResources.started(processId, scope, settled, context)
       });
       if (snapshot.status === "running") {
         pendingExecutions.set(snapshot.processId, execution);
@@ -1215,7 +1377,7 @@ function createExecHandlers(pluginContext, settings) {
         );
       }
       const scope = processScope(context);
-      const snapshot = await processManager.wait({
+      const snapshot = requestResources.terminal(processId, scope, cursor) ?? await processManager.wait({
         processId,
         scope,
         cursor,
@@ -1240,7 +1402,7 @@ function createExecHandlers(pluginContext, settings) {
         );
       }
       const scope = processScope(context);
-      const snapshot = await processManager.cancel({ processId, scope });
+      const snapshot = requestResources.terminal(processId, scope) ?? await processManager.cancel({ processId, scope });
       return finalizeAndRelease({
         snapshot,
         execution,
@@ -1257,6 +1419,18 @@ function createExecHandlers(pluginContext, settings) {
 // plugins/exec/source/index.ts
 var index_default = defineRuntimePlugin((context) => ({
   handlers: createExecHandlers(context, readExecSettings(context.config)),
+  prepareRequest: async (modules, preparation) => {
+    if (!preparation?.requestState) return modules;
+    const handlers = createExecHandlers(
+      context,
+      readExecSettings(context.config),
+      preparation
+    );
+    return modules.map((module2) => ({
+      ...module2,
+      implementation: handlers[module2.definition.name]
+    }));
+  },
   adapters: {
     exec: createExecAdapter()
   }