@abot-ai/runtime 1.5.0 → 1.7.0

package/plugins/system/src/index.cjs

@@ -108,8 +108,28 @@ function defineRuntimePlugin(definition) {
   return definition;
 }
 
+// src/capabilities/tool-context-text.ts
+function hasValidToolContextText(carrier) {
+  const fields = carrier.contextTextFields;
+  if (fields === void 0) return true;
+  if (!Array.isArray(fields) || fields.length === 0 || fields.length > 3)
+    return false;
+  if (new Set(fields).size !== fields.length) return false;
+  for (const field of fields) {
+    if (!isContextTextField(field)) return false;
+    if (typeof carrier[field] !== "string") return false;
+  }
+  return true;
+}
+function isContextTextField(value) {
+  return value === "output" || value === "stdout" || value === "stderr";
+}
+
+// src/capabilities/result-budget.ts
+var CAPABILITY_RESULT_ENVELOPE_MAX_BYTES = 256 * 1024;
+
 // src/plugin-sdk/results.ts
-var PLUGIN_RESULT_SERIALIZED_MAX_BYTES = 128 * 1024;
+var PLUGIN_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 function resultBoundsFailure(code, message) {
   return {
     ok: false,
@@ -119,9 +139,27 @@ function resultBoundsFailure(code, message) {
     errorCode: code
   };
 }
-function enforcePluginResultByteBudget(result) {
-  let serialized;
+function enforcePluginResultByteBudget(result, resultBudget) {
+  let requiresContextTextHost = false;
+  let serializedBytes;
+  let envelopeBytes;
+  let maxBytes = PLUGIN_RESULT_SERIALIZED_MAX_BYTES;
+  let fitsDeclaredBudget = true;
   try {
+    if (!hasValidToolContextText(result)) {
+      return resultBoundsFailure(
+        "plugin_context_text_invalid",
+        "The plugin declared invalid context text fields."
+      );
+    }
+    requiresContextTextHost = result.contextTextFields !== void 0;
+    const lacksContextTextHost = requiresContextTextHost && resultBudget?.acceptsContextText !== true;
+    if (lacksContextTextHost) {
+      return resultBoundsFailure(
+        "plugin_context_text_unavailable",
+        "The host does not support context-managed tool text."
+      );
+    }
     const candidate = JSON.stringify(result);
     if (candidate === void 0) {
       return resultBoundsFailure(
@@ -129,50 +167,60 @@ function enforcePluginResultByteBudget(result) {
         "The plugin produced a result that is not JSON-safe."
       );
     }
-    serialized = candidate;
+    const assessment = resultBudget?.assess(result);
+    serializedBytes = assessment?.serializedBytes ?? Buffer.byteLength(candidate, "utf8");
+    envelopeBytes = assessment?.envelopeBytes ?? serializedBytes;
+    maxBytes = Math.min(assessment?.maxBytes ?? maxBytes, maxBytes);
+    fitsDeclaredBudget = assessment?.fits ?? true;
   } catch {
     return resultBoundsFailure(
       "plugin_result_not_json_safe",
       "The plugin produced a result that is not JSON-safe."
     );
   }
-  if (Buffer.byteLength(serialized, "utf8") > PLUGIN_RESULT_SERIALIZED_MAX_BYTES) {
-    return resultBoundsFailure(
-      "plugin_result_too_large",
-      `The plugin result exceeds the ${PLUGIN_RESULT_SERIALIZED_MAX_BYTES}-byte safety limit.`
-    );
+  const hasResultDeliveryHeadroom = fitsDeclaredBudget && envelopeBytes <= maxBytes;
+  if (!hasResultDeliveryHeadroom) {
+    const message = requiresContextTextHost ? `The plugin result envelope is ${envelopeBytes} bytes (${serializedBytes} total bytes) and exceeds the ${maxBytes}-byte delivery limit.` : `The plugin result is ${serializedBytes} bytes and exceeds the ${maxBytes}-byte delivery limit.`;
+    return resultBoundsFailure("plugin_result_too_large", message);
   }
   return result;
 }
-function successResult(input) {
-  return enforcePluginResultByteBudget({
-    ok: true,
-    ...input.media !== void 0 ? { media: input.media } : {},
-    output: input.output,
-    producedNewInformation: input.producedNewInformation ?? true,
-    ...input.progress !== void 0 ? { progress: input.progress } : {},
-    ...input.actions !== void 0 ? { actions: input.actions } : {},
-    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
-    ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
-    ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
-    ...input.data !== void 0 ? { data: input.data } : {}
-  });
+function successResult(input, resultBudget) {
+  return enforcePluginResultByteBudget(
+    {
+      ok: true,
+      ...input.media !== void 0 ? { media: input.media } : {},
+      output: input.output,
+      producedNewInformation: input.producedNewInformation ?? true,
+      ...input.progress !== void 0 ? { progress: input.progress } : {},
+      ...input.actions !== void 0 ? { actions: input.actions } : {},
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+      ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
+      ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
+      ...input.data !== void 0 ? { data: input.data } : {}
+    },
+    resultBudget
+  );
 }
-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 } : {},
-    ...input.actions !== void 0 ? { actions: input.actions } : {},
-    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
-    ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
-    ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
-    ...input.data !== void 0 ? { data: input.data } : {},
-    error: input.message,
-    errorCode: input.errorCode
-  });
+function failureResult(input, resultBudget) {
+  return enforcePluginResultByteBudget(
+    {
+      ok: false,
+      ...input.interruption ? { interruption: input.interruption } : {},
+      ...input.media !== void 0 ? { media: input.media } : {},
+      output: input.output ?? input.message,
+      producedNewInformation: false,
+      ...input.progress !== void 0 ? { progress: input.progress } : {},
+      ...input.actions !== void 0 ? { actions: input.actions } : {},
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+      ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
+      ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
+      ...input.data !== void 0 ? { data: input.data } : {},
+      error: input.message,
+      errorCode: input.errorCode
+    },
+    resultBudget
+  );
 }
 function failureFromError(error, options) {
   const pathCode = runtimeToolPathErrorCode(error);
@@ -186,6 +234,21 @@ function failureFromError(error, options) {
   });
 }
 
+// src/plugin-sdk/context-text-result.ts
+function deliverPluginTextResult(result, fields, budget) {
+  const assessed = enforcePluginResultByteBudget(result, budget);
+  if (!canHandOffContextText(result, assessed, budget)) return assessed;
+  return enforcePluginResultByteBudget(
+    { ...result, contextTextFields: Object.freeze([...fields]) },
+    budget
+  );
+}
+function canHandOffContextText(original, assessed, budget) {
+  if (budget?.acceptsContextText !== true) return false;
+  if (assessed === original) return false;
+  return assessed.errorCode === "plugin_result_too_large";
+}
+
 // src/capabilities/tool-media.ts
 var TOOL_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
 
@@ -207,25 +270,25 @@ function hostStateDirectory(rootDir) {
 }
 function ensureHostStateDirectory(directory) {
   (0, import_node_fs.mkdirSync)(directory, { recursive: true, mode: 448 });
-  const stat2 = (0, import_node_fs.lstatSync)(directory);
-  if (!stat2.isDirectory()) throw new Error("host_state_directory_invalid");
+  const stat4 = (0, import_node_fs.lstatSync)(directory);
+  if (!stat4.isDirectory()) throw new Error("host_state_directory_invalid");
   if (process.platform === "win32") return;
-  if (stat2.uid !== process.getuid?.())
+  if (stat4.uid !== process.getuid?.())
     throw new Error("host_state_owner_invalid");
-  if ((stat2.mode & 63) !== 0)
+  if ((stat4.mode & 63) !== 0)
     throw new Error("host_state_directory_not_private");
 }
 function readHostPrivateJson(path) {
   try {
-    const stat2 = (0, import_node_fs.lstatSync)(path);
-    if (!stat2.isFile()) throw new Error("host_state_file_invalid");
+    const stat4 = (0, import_node_fs.lstatSync)(path);
+    if (!stat4.isFile()) throw new Error("host_state_file_invalid");
     if (process.platform !== "win32") {
-      if (stat2.uid !== process.getuid?.())
+      if (stat4.uid !== process.getuid?.())
         throw new Error("host_state_owner_invalid");
-      if ((stat2.mode & 63) !== 0)
+      if ((stat4.mode & 63) !== 0)
         throw new Error("host_state_file_not_private");
     }
-    if (stat2.size > 16384) throw new Error("host_state_file_too_large");
+    if (stat4.size > 16384) throw new Error("host_state_file_too_large");
     return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
@@ -2263,7 +2326,7 @@ func capability(_ available: Bool,_ reason: String = "",supported: Bool = true)
   return result
 }
 func rectJSON(_ rect: CGRect) -> [String:Any] {
-  return ["x":rect.minX,"y":rect.minY,"width":rect.width,"height":rect.height]
+  return ["x":Double(rect.minX),"y":Double(rect.minY),"width":Double(rect.width),"height":Double(rect.height)]
 }
 func boundedText(_ value:String,_ limit:Int=256) -> String {
   var result="",length=0
@@ -2568,12 +2631,9 @@ final class CancellationFlag {
     }
   }
 }
-let keyCodes:[String:CGKeyCode] = ["a":0,"s":1,"d":2,"f":3,"h":4,"g":5,"z":6,"x":7,"c":8,"v":9,"b":11,"q":12,"w":13,"e":14,"r":15,"y":16,"t":17,"1":18,"2":19,"3":20,"4":21,"6":22,"5":23,"=":24,"9":25,"7":26,"-":27,"8":28,"0":29,"]":30,"o":31,"u":32,"[":33,"i":34,"p":35,"l":37,"j":38,"'":39,"k":40,";":41,"\\":42,",":43,"/":44,"n":45,"m":46,".":47,"\u{60}":50,"Enter":36,"Return":36,"Tab":48,"Space":49,"Backspace":51,"Delete":117,"Esc":53,"Escape":53,"Meta":55,"Super":55,"Command":55,"Shift":56,"Alt":58,"Option":58,"Ctrl":59,"Control":59,"F1":122,"F2":120,"F3":99,"F4":118,"F5":96,"F6":97,"F7":98,"F8":100,"F9":101,"F10":109,"F11":103,"F12":111,"Home":115,"End":119,"PageUp":116,"PageDown":121,"ArrowLeft":123,"ArrowRight":124,"ArrowDown":125,"ArrowUp":126]
+let keyCodes:[String:CGKeyCode] = ["a":0,"s":1,"d":2,"f":3,"h":4,"g":5,"z":6,"x":7,"c":8,"v":9,"b":11,"q":12,"w":13,"e":14,"r":15,"y":16,"t":17,"1":18,"2":19,"3":20,"4":21,"6":22,"5":23,"=":24,"9":25,"7":26,"-":27,"8":28,"0":29,"]":30,"o":31,"u":32,"[":33,"i":34,"p":35,"l":37,"j":38,"'":39,"k":40,";":41,"\\":42,",":43,"/":44,"n":45,"m":46,".":47,"\u{60}":50,"enter":36,"return":36,"tab":48,"space":49,"backspace":51,"delete":117,"esc":53,"escape":53,"meta":55,"super":55,"command":55,"cmd":55,"shift":56,"alt":58,"option":58,"ctrl":59,"control":59,"f1":122,"f2":120,"f3":99,"f4":118,"f5":96,"f6":97,"f7":98,"f8":100,"f9":101,"f10":109,"f11":103,"f12":111,"home":115,"end":119,"pageup":116,"pagedown":121,"arrowleft":123,"arrowright":124,"arrowdown":125,"arrowup":126]
 func nativeKey(_ value:String) throws -> CGKeyCode {
-  if let key=keyCodes[value] {
-    return key
-  }
-  if value.count==1,let key=keyCodes[value.lowercased()] {
+  if let key=keyCodes[value.lowercased()] {
     return key
   }
   throw NativeFailure("macos_key_unsupported")
@@ -4214,7 +4274,7 @@ var import_node_path4 = require("node:path");
 // src/computer-access/process-runner.ts
 var import_node_child_process4 = require("node:child_process");
 var STREAM_MAX_CHARS = 16e3;
-function runSystemProcess(input) {
+function runSystemProcess(input, capture) {
   if (input.abortSignal?.aborted)
     return Promise.resolve({
       exitCode: null,
@@ -4242,6 +4302,7 @@ function runSystemProcess(input) {
       if (timeout) clearTimeout(timeout);
       if (stopGrace) clearTimeout(stopGrace);
       input.abortSignal?.removeEventListener("abort", abort);
+      capture?.end();
       resolve(
         Object.freeze({
           exitCode,
@@ -4285,18 +4346,25 @@ function runSystemProcess(input) {
       stopGrace.unref();
     };
     const abort = () => stop("aborted");
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      const remaining = streamMaxChars - stdout.length;
-      truncated ||= chunk.length > remaining;
-      stdout += chunk.slice(0, remaining);
-    });
-    child.stderr.on("data", (chunk) => {
-      const remaining = streamMaxChars - stderr.length;
-      truncated ||= chunk.length > remaining;
-      stderr += chunk.slice(0, remaining);
-    });
+    const attachOutput = () => {
+      if (capture) {
+        capture.attach(child.stdout, child.stderr, () => stop("output_failed"));
+        return;
+      }
+      child.stdout.setEncoding("utf8");
+      child.stderr.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        const remaining = streamMaxChars - stdout.length;
+        truncated ||= chunk.length > remaining;
+        stdout += chunk.slice(0, remaining);
+      });
+      child.stderr.on("data", (chunk) => {
+        const remaining = streamMaxChars - stderr.length;
+        truncated ||= chunk.length > remaining;
+        stderr += chunk.slice(0, remaining);
+      });
+    };
+    attachOutput();
     child.once("error", (error) => {
       status = "spawn_failed";
       stderr = error.message.slice(0, STREAM_MAX_CHARS);
@@ -4918,7 +4986,7 @@ async function executeSystemCommand(input) {
     );
   await requireNativeWorkingDirectory(target, cwd);
   const plan = params.elevated === true ? await elevatedSystemCommand({ target, command, cwd, run }) : unprivilegedSystemCommand(target, command, cwd);
-  return run({
+  return (input.runCommand ?? run)({
     ...plan,
     timeoutMs,
     ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
@@ -4962,6 +5030,11 @@ var LEGACY_EVIDENCE_LABELS = {
   launch_request_dispatch: "application launch request dispatch"
 };
 function systemProcessResult(target, result, evidenceScope, application) {
+  return enforcePluginResultByteBudget(
+    buildSystemProcessResult(target, result, evidenceScope, application)
+  );
+}
+function buildSystemProcessResult(target, result, evidenceScope, application) {
   const stdoutOmittedChars = Math.max(
     0,
     result.stdout.length - STREAM_EXCERPT_CHARS
@@ -5004,24 +5077,28 @@ function systemProcessResult(target, result, evidenceScope, application) {
     `Summary omitted characters: stdout=${stdoutOmittedChars}, stderr=${stderrOmittedChars}. Raw stream capture truncated: ${result.outputTruncated}.`
   ].join("\n");
   if (hasSuccessfulSystemObservation(result)) {
-    return successResult({
+    return {
+      ok: true,
+      producedNewInformation: true,
       output,
       stdout: result.stdout,
       stderr: result.stderr,
       exitCode: 0,
       data
-    });
+    };
   }
   const errorCode = result.status === "completed" ? "system_command_failed" : `system_${result.status}`;
-  return failureResult({
+  return {
+    ok: false,
+    producedNewInformation: false,
     errorCode,
-    message: hasUncertainDescendantState(result) ? "System command observation stopped. External or detached descendants may remain; inspect the target before retrying." : "The target did not report successful command completion.",
+    error: hasUncertainDescendantState(result) ? "System command observation stopped. External or detached descendants may remain; inspect the target before retrying." : "The target did not report successful command completion.",
     output,
     stdout: result.stdout,
     stderr: result.stderr,
     ...result.exitCode !== null ? { exitCode: result.exitCode } : {},
     data
-  });
+  };
 }
 function hasSuccessfulSystemObservation(result) {
   if (result.status !== "completed") return false;
@@ -5058,7 +5135,7 @@ function withSystemOperationErrors(operation) {
     }
   };
 }
-function createSystemHandlers(run = runSystemProcess, resolveTarget = (id) => resolveSystemTarget(id, run)) {
+function createSystemHandlers(run = runSystemProcess, resolveTarget = (id) => resolveSystemTarget(id, run), commandOutput) {
   const targets = async () => {
     const observation = await observeSystemTargets(run);
     return successResult({
@@ -5071,12 +5148,15 @@ function createSystemHandlers(run = runSystemProcess, resolveTarget = (id) => re
   };
   const command = async (params, context) => {
     const target = await resolveTarget(readSystemTargetId(params.target));
+    const output = commandOutput?.(context);
     const result = await executeSystemCommand({
       target,
       params,
       run,
+      ...output ? { runCommand: output.run } : {},
       ...context?.abortSignal ? { abortSignal: context.abortSignal } : {}
     });
+    if (output) return output.present(target, result);
     return systemProcessResult(target, result, "command_process_completion");
   };
   const applications = async (params) => {
@@ -5125,6 +5205,255 @@ function createSystemHandlers(run = runSystemProcess, resolveTarget = (id) => re
   };
 }
 
+// src/computer-access/command-output-capture.ts
+var import_node_crypto6 = require("node:crypto");
+var import_node_events = require("node:events");
+var import_node_fs5 = require("node:fs");
+var import_promises6 = require("node:fs/promises");
+var import_node_path8 = require("node:path");
+var import_promises7 = require("node:stream/promises");
+
+// src/computer-access/command-output-retention.ts
+var import_promises5 = require("node:fs/promises");
+var import_node_path7 = require("node:path");
+var DEFAULT_SYSTEM_OUTPUT_RETENTION_MS = 7 * 24 * 60 * 6e4;
+var activeSystemCaptures = /* @__PURE__ */ new Set();
+var jobs = /* @__PURE__ */ new Map();
+var CAPTURE_ID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
+async function cleanupSystemOutput(root, retentionMs) {
+  const entries = await (0, import_promises5.readdir)(root, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  let removed = 0;
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !CAPTURE_ID.test(entry.name)) continue;
+    const directory = (0, import_node_path7.join)(root, entry.name);
+    if (activeSystemCaptures.has(directory)) continue;
+    const files = await (0, import_promises5.readdir)(directory);
+    const times = await Promise.all(files.map(async (file) => (await (0, import_promises5.stat)((0, import_node_path7.join)(directory, file))).mtimeMs));
+    const completedAt = Math.max((await (0, import_promises5.stat)(directory)).mtimeMs, ...times);
+    const captureRetentionMs = await readCaptureRetention(directory, entry.name, retentionMs);
+    if (Date.now() - completedAt < captureRetentionMs) continue;
+    if (activeSystemCaptures.has(directory)) continue;
+    await (0, import_promises5.rm)(directory, { recursive: true });
+    removed += 1;
+  }
+  return removed;
+}
+async function readCaptureRetention(directory, id, fallbackMs) {
+  let receipt;
+  try {
+    receipt = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path7.join)(directory, "receipt.json"), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return fallbackMs;
+    if (error instanceof SyntaxError) return fallbackMs;
+    throw error;
+  }
+  if (receipt === null || typeof receipt !== "object") return fallbackMs;
+  if (!("kind" in receipt) || receipt.kind !== "system_command_output_v1") return fallbackMs;
+  if (!("id" in receipt) || receipt.id !== id) return fallbackMs;
+  if (!("retentionMs" in receipt) || typeof receipt.retentionMs !== "number") return fallbackMs;
+  if (!Number.isSafeInteger(receipt.retentionMs) || receipt.retentionMs < 1) return fallbackMs;
+  return receipt.retentionMs;
+}
+function scheduleSystemOutputCleanup(root, retentionMs) {
+  const previous = jobs.get(root);
+  if (previous) {
+    previous.retentionMs = retentionMs;
+    previous.requested = true;
+    return;
+  }
+  const job = { retentionMs, requested: false };
+  jobs.set(root, job);
+  const sweep = async () => {
+    job.requested = false;
+    let empty = false;
+    try {
+      await cleanupSystemOutput(root, job.retentionMs);
+      empty = (await (0, import_promises5.readdir)(root).catch((error) => {
+        if (error.code === "ENOENT") return [];
+        throw error;
+      })).length === 0;
+    } catch {
+      process.emitWarning("SYSTEM output cleanup failed; retained output was not confirmed removed.", { code: "SYSTEM_OUTPUT_CLEANUP_FAILED" });
+    }
+    if (empty && !job.requested) {
+      jobs.delete(root);
+      return;
+    }
+    const timer = setTimeout(() => {
+      void sweep();
+    }, Math.max(1, Math.min(job.retentionMs, 60 * 6e4)));
+    timer.unref();
+  };
+  void sweep();
+}
+
+// src/computer-access/command-output-capture.ts
+var OUTPUT_IO_CHUNK_BYTES = 64 * 1024;
+async function createSystemOutputCapture(root, retentionMs) {
+  const id = (0, import_node_crypto6.randomUUID)();
+  const directory = (0, import_node_path8.join)(root, id);
+  activeSystemCaptures.add(directory);
+  try {
+    await (0, import_promises6.mkdir)(directory, { recursive: true, mode: 448 });
+  } catch {
+    activeSystemCaptures.delete(directory);
+    throw new SystemOperationError("system_output_storage_failed", "Output storage could not be prepared. The command was not dispatched.");
+  }
+  let failure;
+  let stop;
+  let ended = false;
+  let retained = false;
+  const sources = [];
+  const streams = ["stdout", "stderr"].map((name) => {
+    const path = (0, import_node_path8.join)(directory, name + ".bytes");
+    const sink = (0, import_node_fs5.createWriteStream)(path, { flags: "wx", mode: 384, highWaterMark: OUTPUT_IO_CHUNK_BYTES, flush: true });
+    const completion = (0, import_promises7.finished)(sink).catch(() => {
+      failure ??= "write_failed";
+      stop?.();
+    });
+    return { name, path, sink, completion, hash: (0, import_node_crypto6.createHash)("sha256") };
+  });
+  try {
+    await Promise.all(streams.map(({ sink }) => (0, import_node_events.once)(sink, "open")));
+  } catch {
+    for (const { sink } of streams) sink.destroy();
+    await Promise.all(streams.map(({ completion }) => completion));
+    activeSystemCaptures.delete(directory);
+    scheduleSystemOutputCleanup(root, retentionMs);
+    throw new SystemOperationError("system_output_storage_failed", "Output files could not be opened. The command was not dispatched.");
+  }
+  scheduleSystemOutputCleanup(root, retentionMs);
+  const capture = {
+    attach(stdout, stderr, onFailure) {
+      stop = onFailure;
+      sources.push(stdout, stderr);
+      stdout.on("data", (bytes) => streams[0].hash.update(bytes));
+      stderr.on("data", (bytes) => streams[1].hash.update(bytes));
+      stdout.pipe(streams[0].sink);
+      stderr.pipe(streams[1].sink);
+      if (failure) onFailure();
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      for (const source of sources) {
+        source.unpipe();
+        source.destroy();
+      }
+      for (const { sink } of streams) if (!sink.destroyed && !sink.writableEnded) sink.end();
+    }
+  };
+  let receipt;
+  return {
+    capture,
+    get receipt() {
+      return receipt;
+    },
+    get failure() {
+      return failure;
+    },
+    retain() {
+      retained = true;
+      activeSystemCaptures.add(directory);
+    },
+    release() {
+      retained = false;
+      activeSystemCaptures.delete(directory);
+    },
+    async read(stream, offset, length) {
+      const path = streams.find((entry) => entry.name === stream).path;
+      const file = await (0, import_promises6.open)(path, "r");
+      try {
+        const bytes = Buffer.alloc(length);
+        const { bytesRead } = await file.read(bytes, 0, length, offset);
+        return bytes.subarray(0, bytesRead);
+      } finally {
+        await file.close();
+      }
+    },
+    async finish(result, materialize = true) {
+      capture.end();
+      try {
+        await Promise.all(streams.map(({ completion }) => completion));
+        const sizes = await Promise.all(streams.map(async ({ path }) => {
+          try {
+            return (await (0, import_promises6.stat)(path)).size;
+          } catch {
+            failure ??= "read_failed";
+            return 0;
+          }
+        }));
+        let stdout = "", stderr = "";
+        if (!failure && materialize) {
+          try {
+            [stdout, stderr] = await Promise.all(streams.map(({ path }) => (0, import_promises6.readFile)(path, "utf8")));
+          } catch {
+            failure = "read_failed";
+          }
+        }
+        const completedAt = Date.now();
+        receipt = {
+          id,
+          stdoutBytes: sizes[0],
+          stderrBytes: sizes[1],
+          completedAt: new Date(completedAt).toISOString(),
+          retentionMs,
+          complete: !failure,
+          ...!materialize ? { stdoutSha256: streams[0].hash.digest("hex"), stderrSha256: streams[1].hash.digest("hex") } : {}
+        };
+        try {
+          const temporary = (0, import_node_path8.join)(directory, "receipt.tmp");
+          await (0, import_promises6.writeFile)(temporary, JSON.stringify({
+            kind: "system_command_output_v1",
+            ...receipt,
+            processStatus: result?.status,
+            exitCode: result?.exitCode,
+            spawnedProcess: result?.spawnedProcess,
+            ...failure ? { storageFailure: failure } : {}
+          }), { flag: "wx", mode: 384, flush: true });
+          await (0, import_promises6.rename)(temporary, (0, import_node_path8.join)(directory, "receipt.json"));
+        } catch {
+          failure ??= "receipt_write_failed";
+          receipt = { ...receipt, complete: false };
+        }
+        return { stdout, stderr };
+      } finally {
+        if (!retained) activeSystemCaptures.delete(directory);
+      }
+    }
+  };
+}
+
+// src/computer-access/companion/command-output-protocol.ts
+var SYSTEM_OUTPUT_CAPABILITY = "system_command_output_v1";
+var SYSTEM_OUTPUT_CHUNK_BYTES = 64 * 1024;
+function isStreamByteCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isStreamDigest(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function readSystemOutputTransfer(value) {
+  if (!isHostRecord(value)) throw new Error("system_output_receipt_invalid");
+  if (value.kind !== SYSTEM_OUTPUT_CAPABILITY) throw new Error("system_output_receipt_invalid");
+  if (!isHostIdentifier(value.id)) throw new Error("system_output_receipt_invalid");
+  if (!isStreamByteCount(value.stdoutBytes)) throw new Error("system_output_receipt_invalid");
+  if (!isStreamByteCount(value.stderrBytes)) throw new Error("system_output_receipt_invalid");
+  if (!isStreamDigest(value.stdoutSha256)) throw new Error("system_output_receipt_invalid");
+  if (!isStreamDigest(value.stderrSha256)) throw new Error("system_output_receipt_invalid");
+  return {
+    kind: SYSTEM_OUTPUT_CAPABILITY,
+    id: value.id,
+    stdoutBytes: value.stdoutBytes,
+    stderrBytes: value.stderrBytes,
+    stdoutSha256: value.stdoutSha256,
+    stderrSha256: value.stderrSha256
+  };
+}
+
 // plugins/system/source/computer/public-action.ts
 function readPublicComputerAction(params) {
   const fields = ["desktop_ref", "observation_ref", "action_kind"];
@@ -5287,7 +5616,7 @@ function fits(value) {
 }
 
 // plugins/system/source/computer/request-computers.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 
 // plugins/system/source/request-target-snapshot.ts
 async function captureSystemTargetSnapshot(input) {
@@ -5404,14 +5733,14 @@ function modelSafeRouteObservation(route) {
 }
 
 // plugins/system/source/computer/desktop-bindings.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var DesktopBindings = class {
   current;
   windows = /* @__PURE__ */ new Map();
   observe(result) {
     this.windows.clear();
     const windows = result.windows.map((window) => {
-      const id2 = (0, import_node_crypto6.randomUUID)();
+      const id2 = (0, import_node_crypto7.randomUUID)();
       this.windows.set(id2, window.binding);
       const { binding: _binding, ...details } = window;
       return {
@@ -5427,7 +5756,7 @@ var DesktopBindings = class {
         observation_ref: void 0,
         coordinateSpace: result.desktop.coordinateSpace ?? "native_desktop"
       };
-    const id = (0, import_node_crypto6.randomUUID)();
+    const id = (0, import_node_crypto7.randomUUID)();
     this.current = {
       id,
       issuedAt: Date.now(),
@@ -5612,7 +5941,7 @@ var RequestComputers = class {
     this.connection = connection;
     this.nativeFactory = nativeFactory;
     this.entries = snapshot === void 0 ? routes.map((route) => ({
-      ref: (0, import_node_crypto7.randomUUID)(),
+      ref: (0, import_node_crypto8.randomUUID)(),
       route,
       bindings: new DesktopBindings()
     })) : restoreComputers(routes, snapshot);
@@ -5981,6 +6310,77 @@ function prepareComputerModules(rootDir, modules, routes, connection, preparatio
   }));
 }
 
+// plugins/system/source/companion-command-output.ts
+var import_node_crypto9 = require("node:crypto");
+var import_node_string_decoder = require("node:string_decoder");
+function supportsCompanionCommandOutput(route) {
+  return route.capabilities?.includes(SYSTEM_OUTPUT_CAPABILITY) === true;
+}
+async function executeCompanionCommand(input) {
+  const { route, context } = input;
+  const call = (operation, params, signal) => input.connection.executeHostOperation(input.rootDir, {
+    hostId: route.hostId,
+    connectionId: route.connectionId,
+    operation,
+    params: { ...params, target: route.target },
+    ...signal ? { abortSignal: signal } : {}
+  });
+  const receipt = await call("system_command_capture", {
+    ...input.params,
+    ...input.outputRetentionMs !== void 0 ? { outputRetentionMs: input.outputRetentionMs } : {}
+  }, context?.abortSignal);
+  if (!receipt.data?.outputTransfer && !receipt.ok) return receipt;
+  let transfer;
+  try {
+    transfer = readSystemOutputTransfer(receipt.data?.outputTransfer);
+    const stdout = await readStream(call, transfer, "stdout", context?.abortSignal);
+    const stderr = await readStream(call, transfer, "stderr", context?.abortSignal);
+    const { outputTransfer: _transfer, ...data } = receipt.data ?? {};
+    const delivered = deliverPluginTextResult({
+      ...receipt,
+      stdout,
+      stderr: stderr || receipt.stderr,
+      data: { ...data, outputDelivery: "complete", summaryOmittedChars: { stdout: stdout.length, stderr: stderr.length } }
+    }, ["stdout", "stderr"], context?.resultBudget);
+    if (delivered.errorCode === "plugin_result_too_large") return transferFailure(receipt, context);
+    return delivered;
+  } catch {
+    return transferFailure(receipt, context);
+  } finally {
+    if (transfer) await call("system_command_output_close", { captureId: transfer.id }, AbortSignal.timeout(3e3)).catch(() => void 0);
+  }
+}
+async function readStream(call, transfer, stream, signal) {
+  const size = stream === "stdout" ? transfer.stdoutBytes : transfer.stderrBytes;
+  const digest = stream === "stdout" ? transfer.stdoutSha256 : transfer.stderrSha256;
+  const hash = (0, import_node_crypto9.createHash)("sha256");
+  const decoder = new import_node_string_decoder.StringDecoder("utf8");
+  let text = "";
+  for (let offset = 0; offset < size; offset += SYSTEM_OUTPUT_CHUNK_BYTES) {
+    signal?.throwIfAborted();
+    const part = await call("system_command_output", { captureId: transfer.id, stream, offset }, signal);
+    if (!part.ok) throw new Error("system_output_transfer_failed");
+    const data = part.data;
+    if (data?.captureId !== transfer.id || data.stream !== stream || data.offset !== offset) throw new Error("system_output_chunk_binding_invalid");
+    if (typeof data.bytes !== "string" || data.bytes.length > SYSTEM_OUTPUT_CHUNK_BYTES * 2) throw new Error("system_output_chunk_invalid");
+    const bytes = Buffer.from(data.bytes, "base64");
+    if (bytes.toString("base64") !== data.bytes) throw new Error("system_output_chunk_invalid");
+    if (bytes.length !== Math.min(SYSTEM_OUTPUT_CHUNK_BYTES, size - offset)) throw new Error("system_output_chunk_size_invalid");
+    hash.update(bytes);
+    text += decoder.write(bytes);
+  }
+  if (hash.digest("hex") !== digest) throw new Error("system_output_digest_invalid");
+  return text + decoder.end();
+}
+function transferFailure(receipt, context) {
+  return failureResult({
+    errorCode: "system_output_delivery_pending",
+    message: "The command settled, but its retained output could not be delivered completely. Process receipt is preserved; the command was not replayed.",
+    ...receipt.exitCode !== void 0 ? { exitCode: receipt.exitCode } : {},
+    data: { ...receipt.data, outputDelivery: "pending", commandOk: receipt.ok, commandErrorCode: receipt.errorCode ?? null }
+  }, context?.resultBudget);
+}
+
 // plugins/system/source/host-dispatch.ts
 var defaultSystemHostConnection = {
   readHostStatus,
@@ -6015,6 +6415,8 @@ function boundOperation(input, operation) {
       const route = requireSystemRequestRoute(input.snapshot, params.target);
       if (route.kind === "native")
         return await input.nativeHandlers[operation](params, context);
+      if (operation === "system_command" && supportsCompanionCommandOutput(route))
+        return await executeCompanionCommand({ ...input, route, params, context });
       return await input.connection.executeHostOperation(input.rootDir, {
         hostId: route.hostId,
         connectionId: route.connectionId,
@@ -6067,7 +6469,8 @@ async function prepareSystemRequestModules(rootDir, modules, dependencies = {},
     rootDir,
     snapshot,
     connection,
-    nativeHandlers
+    nativeHandlers,
+    outputRetentionMs: dependencies.outputRetentionMs
   });
   return Object.freeze([
     ...modules.filter((module2) => !isComputerTool(module2.definition.name)).map((module2) => projectSystemRequestModule(module2, snapshot, handlers)),
@@ -6128,8 +6531,85 @@ function systemExecutionBinding(snapshot) {
   };
 }
 
+// plugins/system/source/local-command-output.ts
+var import_node_path9 = require("node:path");
+var CONTEXT_STREAMS = Object.freeze(["stdout", "stderr"]);
+function createLocalSystemCommandOutput(plugin) {
+  const root = (0, import_node_path9.join)(plugin.stateDir, "command-output");
+  const retentionMs = systemCommandOutputRetentionMs(plugin);
+  scheduleSystemOutputCleanup(root, retentionMs);
+  return (context) => {
+    let captured;
+    return {
+      async run(input) {
+        if (input.abortSignal?.aborted) return runSystemProcess(input);
+        captured = await createSystemOutputCapture(root, retentionMs);
+        let result;
+        try {
+          result = await runSystemProcess(input, captured.capture);
+        } catch (error) {
+          await captured.finish();
+          throw error;
+        }
+        const streams = await captured.finish(result);
+        return {
+          ...result,
+          stdout: streams.stdout,
+          stderr: streams.stderr || result.stderr,
+          outputTruncated: Boolean(captured.failure)
+        };
+      },
+      async present(target, result) {
+        if (captured?.failure) return outputFailure(target, result, context, captured.receipt, captured.failure);
+        const receipt = buildSystemProcessResult(target, result, "command_process_completion");
+        const delivered = deliverPluginTextResult({
+          ...receipt,
+          data: { ...receipt.data, ...captured?.receipt ? { outputCapture: captured.receipt } : {} }
+        }, CONTEXT_STREAMS, context?.resultBudget);
+        if (delivered.errorCode === "plugin_result_too_large")
+          return outputFailure(target, result, context, captured?.receipt);
+        return delivered;
+      }
+    };
+  };
+}
+function outputFailure(target, result, context, capture, storageFailure) {
+  return failureResult({
+    errorCode: storageFailure ? "system_output_storage_failed" : "system_output_delivery_pending",
+    message: "The command was dispatched. Its output could not be delivered completely; do not repeat the command just to retrieve output. Inspect the process receipt and retained capture.",
+    ...result.exitCode !== null ? { exitCode: result.exitCode } : {},
+    data: {
+      target: target.id,
+      transport: target.transport,
+      processStatus: result.status,
+      spawnedProcess: result.spawnedProcess ?? null,
+      exitCode: result.exitCode,
+      outputCapture: capture ?? null,
+      ...storageFailure ? { storageFailure } : {},
+      outputDelivery: "pending",
+      evidenceScope: "command_process_completion",
+      independentOutcomeCheck: "not_performed",
+      observationMeta: { kind: "volatile_external", carryPolicy: "never" }
+    }
+  }, context?.resultBudget);
+}
+function systemCommandOutputRetentionMs(plugin) {
+  return readBoundedInteger(plugin.config?.outputRetentionMs, {
+    name: "outputRetentionMs",
+    defaultValue: DEFAULT_SYSTEM_OUTPUT_RETENTION_MS,
+    minimum: 1,
+    maximum: Number.MAX_SAFE_INTEGER
+  });
+}
+
 // plugins/system/source/index.ts
-var index_default = defineRuntimePlugin(({ rootDir }) => ({
-  handlers: { ...createSystemHandlers(), ...unboundComputerHandlers() },
-  prepareRequest: (modules, preparation) => prepareSystemRequestModules(rootDir, modules, {}, preparation)
-}));
+var index_default = defineRuntimePlugin((context) => {
+  const output = createLocalSystemCommandOutput(context);
+  return {
+    handlers: { ...createSystemHandlers(void 0, void 0, output), ...unboundComputerHandlers() },
+    prepareRequest: (modules, preparation) => prepareSystemRequestModules(context.rootDir, modules, {
+      outputRetentionMs: systemCommandOutputRetentionMs(context),
+      createNativeHandlers: (resolve) => createSystemHandlers(void 0, resolve, output)
+    }, preparation)
+  };
+});