@agentorg/computer 0.0.8 → 0.0.10

package/dist/agentcomputer.js

@@ -3753,7 +3753,7 @@ var require_websocket_server = __commonJS({
 // src/main.ts
 import { readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute2, join as join12, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join11, resolve as resolve5 } from "node:path";
 import { parseArgs } from "node:util";
 import { isMainThread as isMainThread2 } from "node:worker_threads";
 
@@ -3772,9 +3772,9 @@ var playwright = () => {
 // src/browser-host.ts
 var sandboxFor = (options) => options.sandbox ?? (process.platform !== "linux" || !options.executable && !["chromium", "chrome-for-testing"].includes(options.channel ?? "chrome"));
 async function hostBrowser(options) {
-  const run2 = mkdtempSync(join("/tmp", "agentcomputer-"));
-  process.env.XDG_RUNTIME_DIR = run2;
-  process.env.TMPDIR = run2;
+  const run3 = mkdtempSync(join("/tmp", "agentcomputer-"));
+  process.env.XDG_RUNTIME_DIR = run3;
+  process.env.TMPDIR = run3;
   const context = await playwright().chromium.launchPersistentContext(options.profile, {
     headless: true,
     chromiumSandbox: sandboxFor(options),
@@ -3783,7 +3783,7 @@ async function hostBrowser(options) {
   const browser = context.browser();
   if (!browser) throw new Error("The browser can't be shared.");
   const { endpoint } = await browser.bind("agentcomputer");
-  if (!endpoint.startsWith(run2 + sep)) {
+  if (!endpoint.startsWith(run3 + sep)) {
     await context.close();
     throw new Error(`The browser's socket isn't in its own folder: ${endpoint}`);
   }
@@ -3797,7 +3797,7 @@ async function hostBrowser(options) {
     });
     await context.close().catch(() => {
     });
-    rmSync(run2, { recursive: true, force: true });
+    rmSync(run3, { recursive: true, force: true });
     process.exit(0);
   };
   for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => void stop());
@@ -3846,13 +3846,13 @@ async function serveBrowserMcp(options) {
 }
 
 // src/container.ts
-import { execFile, spawn as spawn3 } from "node:child_process";
+import { execFile as execFile2, spawn as spawn3 } from "node:child_process";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { connect } from "node:net";
-import { join as join9 } from "node:path";
+import { join as join8 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 import { Readable as Readable3 } from "node:stream";
-import { promisify } from "node:util";
+import { promisify as promisify2 } from "node:util";
 
 // src/browser.ts
 import { spawn } from "node:child_process";
@@ -6616,10 +6616,10 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
     }
     return void 0;
   });
-  const first = def.options.length === 1 ? def.options[0]._zod.run : null;
+  const first2 = def.options.length === 1 ? def.options[0]._zod.run : null;
   inst._zod.parse = (payload, ctx) => {
-    if (first) {
-      return first(payload, ctx);
+    if (first2) {
+      return first2(payload, ctx);
     }
     let async = false;
     const results = [];
@@ -9017,9 +9017,9 @@ var numberProcessor = (schema, ctx, _json, params) => {
       else
         handleUnrepresentable(schema, ctx, json4, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
-    const [first, ...rest] = divisors;
-    if (first !== void 0)
-      json4.multipleOf = first;
+    const [first2, ...rest] = divisors;
+    if (first2 !== void 0)
+      json4.multipleOf = first2;
     if (rest.length)
       json4.allOf = [...json4.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
   }
@@ -19229,8 +19229,8 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     }
     if (bestLength < 2) return hextets.join(":");
     const head = hextets.slice(0, bestStart).join(":");
-    const tail = hextets.slice(bestStart + bestLength).join(":");
-    return head + "::" + tail;
+    const tail2 = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail2;
   }
   function normalizeIPv6Address(input2) {
     const compression = input2.indexOf("::");
@@ -28153,10 +28153,12 @@ var Browser = class {
 // src/inside.ts
 import { createServer as createServer3 } from "node:http";
 import { homedir } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/runtime.ts
-import { join as join7 } from "node:path";
+import { chmodSync as chmodSync2, existsSync, statSync as statSync2 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname3, join as join6 } from "node:path";
 
 // node_modules/@agentorg/exec/dist/lib.js
 import { realpathSync } from "node:fs";
@@ -28411,7 +28413,7 @@ var require_ignore = __commonJS2({
         //   ever starts again inside it -- `(\\+?) ` did, which made a long run
         //   quadratic.
         /(\\+)( ?)/g,
-        (_, run2, space) => space ? run2.slice(0, run2.length - run2.length % 2) + SPACE2 : run2,
+        (_, run3, space) => space ? run3.slice(0, run3.length - run3.length % 2) + SPACE2 : run3,
         ESCAPE + SPACE2
       ],
       // git's wildmatch() reads a run of two or more asterisks as one globstar
@@ -28597,10 +28599,10 @@ var require_ignore = __commonJS2({
     var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
     var replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
     var WILDCARD2 = "[^\\/]*";
-    var separatorAfter = (run2, at) => {
+    var separatorAfter = (run3, at) => {
       let separator = EMPTY;
-      for (let index = at + 1; index < run2.length && !run2[index].wildcard; index++) {
-        separator += run2[index].single;
+      for (let index = at + 1; index < run3.length && !run3[index].wildcard; index++) {
+        separator += run3[index].single;
       }
       return separator;
     };
@@ -28660,26 +28662,26 @@ var require_ignore = __commonJS2({
         }
       }
       let out = EMPTY;
-      let run2 = [];
+      let run3 = [];
       const flush = () => {
         let lastWildcard;
-        run2.forEach((token, at) => {
+        run3.forEach((token, at) => {
           if (token.wildcard) {
             lastWildcard = at;
           }
         });
-        run2.forEach((token, at) => {
+        run3.forEach((token, at) => {
           if (!token.wildcard) {
             out += token.single;
             return;
           }
-          out += at === lastWildcard ? WILDCARD2 : `(?:(?!${separatorAfter(run2, at)})[^\\/])*`;
+          out += at === lastWildcard ? WILDCARD2 : `(?:(?!${separatorAfter(run3, at)})[^\\/])*`;
         });
-        run2 = [];
+        run3 = [];
       };
       tokens.forEach((token) => {
         if (token.boundary === void 0) {
-          run2.push(token);
+          run3.push(token);
           return;
         }
         flush();
@@ -28959,11 +28961,11 @@ var require_ignore = __commonJS2({
       return true;
     };
     var isNotRelative = (path) => {
-      const first = path.charCodeAt(0);
-      if (first === SLASH_CODE) {
+      const first2 = path.charCodeAt(0);
+      if (first2 === SLASH_CODE) {
         return true;
       }
-      if (first !== DOT_CODE) {
+      if (first2 !== DOT_CODE) {
         return false;
       }
       if (path.length === 1) {
@@ -32872,10 +32874,10 @@ var $ZodUnion2 = /* @__PURE__ */ $constructor2("$ZodUnion", (inst, def) => {
     }
     return void 0;
   });
-  const first = def.options.length === 1 ? def.options[0]._zod.run : null;
+  const first2 = def.options.length === 1 ? def.options[0]._zod.run : null;
   inst._zod.parse = (payload, ctx) => {
-    if (first) {
-      return first(payload, ctx);
+    if (first2) {
+      return first2(payload, ctx);
     }
     let async = false;
     const results = [];
@@ -32932,10 +32934,10 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
 var $ZodXor2 = /* @__PURE__ */ $constructor2("$ZodXor", (inst, def) => {
   $ZodUnion2.init(inst, def);
   def.inclusive = false;
-  const first = def.options.length === 1 ? def.options[0]._zod.run : null;
+  const first2 = def.options.length === 1 ? def.options[0]._zod.run : null;
   inst._zod.parse = (payload, ctx) => {
-    if (first) {
-      return first(payload, ctx);
+    if (first2) {
+      return first2(payload, ctx);
     }
     let async = false;
     const results = [];
@@ -45270,9 +45272,9 @@ var numberProcessor2 = (schema, ctx, _json, params) => {
       else
         handleUnrepresentable2(schema, ctx, json32, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
-    const [first, ...rest] = divisors;
-    if (first !== void 0)
-      json32.multipleOf = first;
+    const [first2, ...rest] = divisors;
+    if (first2 !== void 0)
+      json32.multipleOf = first2;
     if (rest.length)
       json32.allOf = [...json32.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
   }
@@ -47956,14 +47958,14 @@ function checkArrayGuards(arraySchema, guards) {
         const key = canonicalKey(items[i], /* @__PURE__ */ new Set());
         if (key === null)
           continue;
-        const first = firstSeen.get(key);
-        if (first === void 0) {
+        const first2 = firstSeen.get(key);
+        if (first2 === void 0) {
           firstSeen.set(key, i);
           continue;
         }
         payload.issues.push({
           code: "custom",
-          message: `Array items must be unique: element at index ${i} duplicates the one at index ${first}`,
+          message: `Array items must be unique: element at index ${i} duplicates the one at index ${first2}`,
           input: items,
           path: [i],
           continue: true
@@ -48441,7 +48443,7 @@ function visit(schema, fnOrHandlers) {
     return h ? h(node22, rewritten) : node22;
   };
   const cache = /* @__PURE__ */ new Map();
-  function run2(s) {
+  function run3(s) {
     const cached22 = cache.get(s);
     if (cached22 === RESOLVING) {
       return new $ZodLazy2({
@@ -48467,21 +48469,21 @@ function visit(schema, fnOrHandlers) {
         let changed2 = false;
         const newShape = {};
         for (const k of keys) {
-          const mapped = run2(oldShape[k]);
+          const mapped = run3(oldShape[k]);
           if (mapped !== oldShape[k])
             changed2 = true;
           newShape[k] = mapped;
         }
         let newCatchall = def.catchall;
         if (def.catchall) {
-          newCatchall = run2(def.catchall);
+          newCatchall = run3(def.catchall);
           if (newCatchall !== def.catchall)
             changed2 = true;
         }
         return changed2 ? clone2(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
       }
       case "array": {
-        const mapped = run2(def.element);
+        const mapped = run3(def.element);
         return mapped === def.element ? s : clone2(s, { ...def, element: mapped });
       }
       case "tuple": {
@@ -48489,14 +48491,14 @@ function visit(schema, fnOrHandlers) {
         let changed2 = false;
         const newItems = [];
         for (const item of oldItems) {
-          const mapped = run2(item);
+          const mapped = run3(item);
           if (mapped !== item)
             changed2 = true;
           newItems.push(mapped);
         }
         let newRest = def.rest;
         if (def.rest) {
-          newRest = run2(def.rest);
+          newRest = run3(def.rest);
           if (newRest !== def.rest)
             changed2 = true;
         }
@@ -48504,12 +48506,12 @@ function visit(schema, fnOrHandlers) {
       }
       case "record":
       case "map": {
-        const newKey = run2(def.keyType);
-        const newVal = run2(def.valueType);
+        const newKey = run3(def.keyType);
+        const newVal = run3(def.valueType);
         return newKey === def.keyType && newVal === def.valueType ? s : clone2(s, { ...def, keyType: newKey, valueType: newVal });
       }
       case "set": {
-        const newVal = run2(def.valueType);
+        const newVal = run3(def.valueType);
         return newVal === def.valueType ? s : clone2(s, { ...def, valueType: newVal });
       }
       case "union": {
@@ -48517,7 +48519,7 @@ function visit(schema, fnOrHandlers) {
         let changed2 = false;
         const newOptions = [];
         for (const opt of oldOptions) {
-          const mapped = run2(opt);
+          const mapped = run3(opt);
           if (mapped !== opt)
             changed2 = true;
           newOptions.push(mapped);
@@ -48525,8 +48527,8 @@ function visit(schema, fnOrHandlers) {
         return changed2 ? clone2(s, { ...def, options: newOptions }) : s;
       }
       case "intersection": {
-        const newLeft = run2(def.left);
-        const newRight = run2(def.right);
+        const newLeft = run3(def.left);
+        const newRight = run3(def.right);
         return newLeft === def.left && newRight === def.right ? s : clone2(s, { ...def, left: newLeft, right: newRight });
       }
       case "optional":
@@ -48538,23 +48540,23 @@ function visit(schema, fnOrHandlers) {
       case "nonoptional":
       case "promise":
       case "success": {
-        const newInner = run2(def.innerType);
+        const newInner = run3(def.innerType);
         return newInner === def.innerType ? s : clone2(s, { ...def, innerType: newInner });
       }
       case "pipe": {
-        const newIn = run2(def.in);
-        const newOut = run2(def.out);
+        const newIn = run3(def.in);
+        const newOut = run3(def.out);
         return newIn === def.in && newOut === def.out ? s : clone2(s, { ...def, in: newIn, out: newOut });
       }
       case "function": {
-        const newInput = run2(def.input);
-        const newOutput = run2(def.output);
+        const newInput = run3(def.input);
+        const newOutput = run3(def.output);
         return newInput === def.input && newOutput === def.output ? s : clone2(s, { ...def, input: newInput, output: newOutput });
       }
       case "lazy": {
         const original = def.getter;
         const { _cachedInner, ...rest } = def;
-        return clone2(s, { ...rest, getter: () => run2(original()) });
+        return clone2(s, { ...rest, getter: () => run3(original()) });
       }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
@@ -48585,7 +48587,7 @@ function visit(schema, fnOrHandlers) {
       }
     }
   }
-  return run2(schema);
+  return run3(schema);
 }
 function deepPartial(schema) {
   return visit(schema, {
@@ -56945,8 +56947,8 @@ var require_utils2 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
     }
     if (bestLength < 2) return hextets.join(":");
     const head = hextets.slice(0, bestStart).join(":");
-    const tail = hextets.slice(bestStart + bestLength).join(":");
-    return head + "::" + tail;
+    const tail2 = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail2;
   }
   function normalizeIPv6Address(input2) {
     const compression = input2.indexOf("::");
@@ -63419,9 +63421,9 @@ var WebStandardStreamableHTTPServerTransport = class {
       }
     });
   }
-  async _checkScopeChallenge(messages, authInfo) {
+  async _checkScopeChallenge(messages2, authInfo) {
     if (!this._scopeChallengeResolver) return;
-    const challenge = await findScopeChallenge(messages.filter((message) => isJSONRPCRequest2(message)), authInfo, this._scopeChallengeResolver);
+    const challenge = await findScopeChallenge(messages2.filter((message) => isJSONRPCRequest2(message)), authInfo, this._scopeChallengeResolver);
     return challenge === void 0 ? void 0 : createScopeChallengeResponse(challenge, scopeChallengeResourceMetadataUrl(authInfo));
   }
   /**
@@ -63719,21 +63721,21 @@ data:
         this.onerror?.(/* @__PURE__ */ new Error(`Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE} messages`));
         return this.createJsonErrorResponse(400, -32600, `Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE} messages`);
       }
-      let messages;
+      let messages2;
       try {
-        messages = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema2.parse(msg)) : [JSONRPCMessageSchema2.parse(rawMessage)];
+        messages2 = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema2.parse(msg)) : [JSONRPCMessageSchema2.parse(rawMessage)];
       } catch (error62) {
         this.onerror?.(error62);
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
       if (this._closed) return this.createJsonErrorResponse(404, -32001, "Session not found");
-      const isInitializationRequest = messages.some((element) => isInitializeRequest2(element));
+      const isInitializationRequest = messages2.some((element) => isInitializeRequest2(element));
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== void 0) {
           this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Server already initialized"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
         }
-        if (messages.length > 1) {
+        if (messages2.length > 1) {
           this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Only one initialization request is allowed"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
         }
@@ -63750,21 +63752,21 @@ data:
       if (this._closed) return this.createJsonErrorResponse(404, -32001, "Session not found");
       let scopeChallengeResponse;
       try {
-        scopeChallengeResponse = await this._checkScopeChallenge(messages, options?.authInfo);
+        scopeChallengeResponse = await this._checkScopeChallenge(messages2, options?.authInfo);
       } catch (error62) {
         this.onerror?.(error62);
         return this.createJsonErrorResponse(500, -32603, "Internal server error");
       }
       if (scopeChallengeResponse) return scopeChallengeResponse;
-      if (!messages.some((element) => isJSONRPCRequest2(element))) {
-        for (const message of messages) this.onmessage?.(message, {
+      if (!messages2.some((element) => isJSONRPCRequest2(element))) {
+        for (const message of messages2) this.onmessage?.(message, {
           authInfo: options?.authInfo,
           request
         });
         return new Response(null, { status: 202 });
       }
       const streamId = crypto.randomUUID();
-      const initRequest = messages.find((m) => isInitializeRequest2(m));
+      const initRequest = messages2.find((m) => isInitializeRequest2(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION2;
       if (this._enableJsonResponse) return new Promise((resolve42) => {
         this._streamMapping.set(streamId, {
@@ -63773,8 +63775,8 @@ data:
             this._streamMapping.delete(streamId);
           }
         });
-        for (const message of messages) if (isJSONRPCRequest2(message)) this._requestToStreamMapping.set(message.id, streamId);
-        for (const message of messages) this.onmessage?.(message, {
+        for (const message of messages2) if (isJSONRPCRequest2(message)) this._requestToStreamMapping.set(message.id, streamId);
+        for (const message of messages2) this.onmessage?.(message, {
           authInfo: options?.authInfo,
           request
         });
@@ -63798,7 +63800,7 @@ data:
         "X-Accel-Buffering": "no"
       };
       if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-      for (const message of messages) if (isJSONRPCRequest2(message)) {
+      for (const message of messages2) if (isJSONRPCRequest2(message)) {
         this._streamMapping.set(streamId, {
           controller: streamController,
           encoder,
@@ -63814,7 +63816,7 @@ data:
         this._requestToStreamMapping.set(message.id, streamId);
       }
       await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
-      for (const message of messages) {
+      for (const message of messages2) {
         let closeSSEStream;
         let closeStandaloneSSEStream;
         if (isJSONRPCRequest2(message) && this._eventStore && this.supportsEmptySSEData(clientProtocolVersion)) {
@@ -65811,10 +65813,10 @@ function cut(text22, max) {
   if (text22.length <= max) return text22;
   const half = Math.max(1, Math.floor(max / 2));
   const head = text22.slice(0, half).replace(/[\uD800-\uDBFF]$/, "");
-  const tail = text22.slice(-half).replace(/^[\uDC00-\uDFFF]/, "");
+  const tail2 = text22.slice(-half).replace(/^[\uDC00-\uDFFF]/, "");
   return `${head}
-\u2026 ${text22.length - head.length - tail.length} characters cut \u2026
-${tail}`;
+\u2026 ${text22.length - head.length - tail2.length} characters cut \u2026
+${tail2}`;
 }
 var Pending = class {
   #head = "";
@@ -65850,6 +65852,10 @@ var DEFAULT_YIELD_MS = 1e4;
 var MIN_POLL_MS = 5e3;
 var WRITE_YIELD_MS = 250;
 var MAX_RUNNING = 64;
+var MAX_ENDED = 64;
+var KEPT = 64 * 1024;
+var CMD_SHOWN = 200;
+var MAX_SIZE = 1e3;
 var DEFAULT_MAX_TOKENS = 7e3;
 var DRAIN_MS = 200;
 var KILL_AFTER_MS = 1e3;
@@ -65863,48 +65869,183 @@ var SIGNALS = {
   SIGTERM: 15
 };
 var clamp = (value, low, high) => Math.min(Math.max(value, low), high);
+var tail = (text22) => text22.slice(-KEPT).replace(/^[\uDC00-\uDFFF]/, "");
 var Sessions = class {
   #sessions = /* @__PURE__ */ new Map();
+  /** Those that have ended and are still listed, in the order they ended. */
+  #ended = [];
   #root;
   #emit;
+  #pty;
   constructor(root, emit = () => {
-  }) {
+  }, pty2) {
     this.#root = root;
     this.#emit = emit;
+    this.#pty = pty2;
   }
   /** Run `cmd` in a login shell, in `workdir` or the workspace. */
   async exec(input2) {
-    const running = [...this.#sessions.values()].filter((s) => s.exitCode === void 0);
-    if (running.length >= MAX_RUNNING)
-      throw new ExecRefused(`${MAX_RUNNING} commands are running. Wait for one, or stop one.`);
+    this.#room();
     const started = Date.now();
     const session = this.#start(input2.cmd, input2.workdir ?? this.#root);
     const wait = clamp(input2.yield_time_ms ?? DEFAULT_YIELD_MS, MIN_YIELD_MS, MAX_YIELD_MS);
     return this.#after(session, wait, started, input2.max_output_tokens);
   }
   /**
-   * Type into a running command, or with no `chars` wait and see what it has written. Ctrl-C
-   * (`\u0003`) interrupts it and Ctrl-D (`\u0004`) ends its input.
+   * Type into a running terminal, or with no `chars` wait and see what it has written. In a
+   * command, Ctrl-C (`\u0003`) interrupts it and Ctrl-D (`\u0004`) ends its input; a shell on a
+   * terminal device is typed into as it is.
    */
   async write(input2) {
     const session = this.#sessions.get(input2.session_id);
-    if (!session) throw new ExecRefused(`No session ${input2.session_id.slice(0, 64)} is running.`);
+    if (!session || session.reported)
+      throw new ExecRefused(`No session ${input2.session_id.slice(0, 64)} is running.`);
     const started = Date.now();
     const chars = input2.chars ?? "";
-    if (session.exitCode === void 0) this.#type(session, chars);
+    if (session.exitCode === void 0) session.type(chars);
     const wait = chars ? clamp(input2.yield_time_ms ?? WRITE_YIELD_MS, MIN_YIELD_MS, MAX_YIELD_MS) : clamp(input2.yield_time_ms ?? MIN_POLL_MS, MIN_POLL_MS, MAX_YIELD_MS);
     return this.#after(session, wait, started, input2.max_output_tokens);
   }
-  /** Stop every command: a polite signal, then a certain one. */
+  /** Every terminal, the oldest first: those running, and the last that ended. */
+  list() {
+    return [...this.#sessions.values()].map((session) => ({
+      id: session.id,
+      by: session.by,
+      cmd: session.cmd,
+      workdir: session.workdir,
+      tty: session.tty,
+      at: session.at,
+      output: tail(session.last),
+      ...session.exitCode === void 0 ? {} : { exitCode: session.exitCode, endedAt: session.endedAt }
+    }));
+  }
+  /** Start a person's login shell in the workspace, on a terminal device of this size. */
+  open(columns, rows) {
+    if (!this.#pty)
+      throw new ExecRefused("A shell needs a terminal device, and this host has none to give.");
+    this.#room();
+    const size = sized(columns, rows);
+    const file2 = process.env.SHELL || "/bin/bash";
+    let shell;
+    try {
+      shell = this.#pty(file2, ["-l"], {
+        name: "xterm-256color",
+        ...size,
+        cwd: this.#root,
+        env: process.env
+      });
+    } catch (error62) {
+      const why = error62 instanceof Error ? error62.message : String(error62);
+      throw new ExecRefused(`The shell didn't start: ${why}`);
+    }
+    const { session, wrote, finish } = this.#begin("person", file2, this.#root, true, {
+      type: (chars) => shell.write(chars),
+      signal(signal) {
+        try {
+          shell.kill(signal);
+        } catch {
+        }
+      },
+      resize: (cols, lines) => shell.resize(cols, lines)
+    });
+    shell.onData((text22) => wrote(text22));
+    shell.onExit(({ exitCode, signal }) => finish(signal ? 128 + signal : exitCode));
+    return session.id;
+  }
+  /** Type into a running terminal, as `write` does and with no answer. */
+  type(id, chars) {
+    this.#running(id).type(chars);
+  }
+  /** Give a shell's terminal device a new size. */
+  resize(id, columns, rows) {
+    const session = this.#running(id);
+    if (!session.resize) throw new ExecRefused("Only a shell on a terminal device has a size.");
+    const size = sized(columns, rows);
+    session.resize(size.cols, size.rows);
+  }
+  /**
+   * End one terminal: an interrupt, then a certain signal. It resolves once the terminal has
+   * ended or that signal is sent. One that has ended is left alone.
+   */
+  async stop(id) {
+    const session = this.#sessions.get(id);
+    if (!session) throw new ExecRefused(`No terminal ${id.slice(0, 64)} is here.`);
+    await this.#end([session], "SIGINT");
+  }
+  /** Stop every terminal: a polite signal, then a certain one. */
   async stopAll() {
-    const running = [...this.#sessions.values()].filter((s) => s.exitCode === void 0);
-    for (const session of running) this.#signal(session, "SIGTERM");
+    await this.#end([...this.#sessions.values()], "SIGTERM");
+  }
+  async #end(sessions, polite) {
+    const running = sessions.filter((s) => s.exitCode === void 0);
+    for (const session of running) session.signal(session.tty ? "SIGHUP" : polite);
+    let timer;
     await Promise.race([
       Promise.all(running.map((s) => s.ended)),
-      new Promise((done) => setTimeout(done, KILL_AFTER_MS))
+      new Promise((done) => {
+        timer = setTimeout(done, KILL_AFTER_MS);
+      })
     ]);
-    for (const session of running)
-      if (session.exitCode === void 0) this.#signal(session, "SIGKILL");
+    clearTimeout(timer);
+    for (const session of running) if (session.exitCode === void 0) session.signal("SIGKILL");
+  }
+  #room() {
+    const running = [...this.#sessions.values()].filter((s) => s.exitCode === void 0);
+    if (running.length >= MAX_RUNNING)
+      throw new ExecRefused(`${MAX_RUNNING} commands are running. Wait for one, or stop one.`);
+  }
+  #running(id) {
+    const session = this.#sessions.get(id);
+    if (!session) throw new ExecRefused(`No terminal ${id.slice(0, 64)} is here.`);
+    if (session.exitCode !== void 0) throw new ExecRefused("That terminal has ended.");
+    return session;
+  }
+  /**
+   * List a terminal that has just started, with the ways to act on its process, and give the two
+   * ways that process reports back.
+   */
+  #begin(by, cmd, workdir, tty, acts) {
+    const id = `s_${randomBytes(9).toString("hex")}`;
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    let done = () => {
+    };
+    const session = {
+      id,
+      by,
+      cmd,
+      workdir,
+      tty,
+      at,
+      pending: new Pending(),
+      last: "",
+      ended: new Promise((resolve42) => {
+        done = resolve42;
+      }),
+      ...acts
+    };
+    this.#sessions.set(id, session);
+    this.#emit({ type: "start", id, by, cmd, workdir, tty, at });
+    const wrote = (text22, stream) => {
+      if (!text22) return;
+      session.pending.add(text22);
+      session.last += text22;
+      if (session.last.length > 2 * KEPT) session.last = tail(session.last);
+      this.#emit({ type: "output", id, ...stream ? { stream } : {}, text: text22 });
+    };
+    const finish = (exitCode) => {
+      if (session.exitCode !== void 0) return;
+      session.exitCode = exitCode;
+      session.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.#emit({ type: "exit", id, exitCode, at: session.endedAt });
+      this.#ended.push(session);
+      if (this.#ended.length > MAX_ENDED) {
+        const read = this.#ended.findIndex((one) => one.reported);
+        const [old] = this.#ended.splice(Math.max(read, 0), 1);
+        this.#sessions.delete(old.id);
+      }
+      done();
+    };
+    return { session, wrote, finish };
   }
   #start(cmd, cwd) {
     const child = spawn2(process.env.SHELL || "/bin/bash", ["-lc", cmd], {
@@ -65913,62 +66054,44 @@ var Sessions = class {
       // Its own process group, so a signal reaches what it started.
       detached: true
     });
-    const pending = new Pending();
-    const id = `s_${randomBytes(9).toString("hex")}`;
-    const session = { id, child, pending };
-    this.#emit({ type: "start", id, cmd, workdir: cwd, at: (/* @__PURE__ */ new Date()).toISOString() });
+    const signal = (name) => {
+      try {
+        if (child.pid) process.kill(-child.pid, name);
+      } catch {
+      }
+    };
+    const type = (chars) => {
+      for (const part of chars.split(new RegExp("(\\p{Cc})", "u"))) {
+        if (part === "") signal("SIGINT");
+        else if (part === "") child.stdin.end();
+        else if (part && child.stdin.writable) child.stdin.write(part);
+      }
+    };
+    const { session, wrote, finish } = this.#begin("agent", cmd, cwd, false, { type, signal });
     for (const [name, stream] of [
       ["stdout", child.stdout],
       ["stderr", child.stderr]
     ]) {
       const decoder = new StringDecoder("utf8");
-      stream.on("data", (chunk) => {
-        const text22 = decoder.write(chunk);
-        pending.add(text22);
-        if (text22) this.#emit({ type: "output", id, stream: name, text: text22 });
-      });
+      stream.on("data", (chunk) => wrote(decoder.write(chunk), name));
     }
     child.stdin.on("error", () => {
     });
-    session.ended = new Promise((done) => {
-      const finish = (code) => {
-        if (session.exitCode !== void 0) return;
-        session.exitCode = code;
-        this.#emit({ type: "exit", id, exitCode: code, at: (/* @__PURE__ */ new Date()).toISOString() });
-        done();
-      };
-      child.once("error", (error62) => {
-        pending.add(`${error62.message}
-`);
-        this.#emit({ type: "output", id, stream: "stderr", text: `${error62.message}
-` });
-        finish(127);
-      });
-      child.once("exit", (code, signal) => {
-        const exitCode = code ?? 128 + (signal ? SIGNALS[signal] ?? 1 : 1);
-        const late = setTimeout(() => finish(exitCode), DRAIN_MS);
-        child.once("close", () => {
-          clearTimeout(late);
-          finish(exitCode);
-        });
+    child.once("error", (error62) => {
+      wrote(`${error62.message}
+`, "stderr");
+      finish(127);
+    });
+    child.once("exit", (code, signal2) => {
+      const exitCode = code ?? 128 + (signal2 ? SIGNALS[signal2] ?? 1 : 1);
+      const late = setTimeout(() => finish(exitCode), DRAIN_MS);
+      child.once("close", () => {
+        clearTimeout(late);
+        finish(exitCode);
       });
     });
-    this.#sessions.set(session.id, session);
     return session;
   }
-  #type(session, chars) {
-    for (const part of chars.split(new RegExp("(\\p{Cc})", "u"))) {
-      if (part === "") this.#signal(session, "SIGINT");
-      else if (part === "") session.child.stdin.end();
-      else if (part && session.child.stdin.writable) session.child.stdin.write(part);
-    }
-  }
-  #signal(session, signal) {
-    try {
-      if (session.child.pid) process.kill(-session.child.pid, signal);
-    } catch {
-    }
-  }
   async #after(session, waitMs, started, maxTokens) {
     let timer;
     await Promise.race([
@@ -65979,7 +66102,7 @@ var Sessions = class {
     ]);
     clearTimeout(timer);
     const exited = session.exitCode !== void 0;
-    if (exited) this.#sessions.delete(session.id);
+    if (exited) session.reported = true;
     return {
       exit_code: exited ? session.exitCode : null,
       seconds: Math.round(Date.now() - started) / 1e3,
@@ -65988,6 +66111,12 @@ var Sessions = class {
     };
   }
 };
+function sized(columns, rows) {
+  for (const value of [columns, rows])
+    if (!Number.isInteger(value) || value < 1 || value > MAX_SIZE)
+      throw new ExecRefused(`A terminal has 1 to ${MAX_SIZE} columns and rows.`);
+  return { cols: columns, rows };
+}
 function formatAnswer(answer) {
   return [
     `exit_code: ${answer.exit_code ?? "running"}`,
@@ -65997,6 +66126,31 @@ function formatAnswer(answer) {
     answer.text
   ].join("\n");
 }
+function listing(terminals) {
+  return terminals.map((one) => {
+    const line = one.cmd.split("\n", 1)[0].slice(0, CMD_SHOWN);
+    const shown = line.replace(/[\uD800-\uDBFF]$/, "");
+    return {
+      session_id: one.id,
+      started_by: one.by,
+      since: one.at,
+      exit_code: one.exitCode ?? null,
+      cmd: shown === one.cmd ? shown : `${shown}\u2026`
+    };
+  });
+}
+function formatSessions(listed) {
+  if (listed.length === 0) return "No sessions.";
+  return listed.map(
+    (one) => [
+      `session_id: ${one.session_id}`,
+      `started_by: ${one.started_by}`,
+      `since: ${one.since}`,
+      `exit_code: ${one.exit_code ?? "running"}`,
+      `cmd: ${one.cmd}`
+    ].join("\n")
+  ).join("\n\n");
+}
 var DEFAULT_LINES = 2e3;
 var MAX_READ_CHARS = 28e3;
 var MAX_LINE_CHARS = 2e3;
@@ -66060,10 +66214,10 @@ function createFiles(root) {
     /** Numbered lines of a file. */
     read: (input2) => refusing(async () => {
       const lines = (await text22(await at(input2.path), input2.path)).split("\n");
-      const first = Math.max(input2.offset ?? 1, 1);
-      const shown = lines.slice(first - 1, first - 1 + (input2.limit ?? DEFAULT_LINES)).map((line, i) => `${first + i}	${cut(line, MAX_LINE_CHARS)}`);
-      const last = first + shown.length - 1;
-      return `lines ${first}-${last} of ${lines.length}
+      const first2 = Math.max(input2.offset ?? 1, 1);
+      const shown = lines.slice(first2 - 1, first2 - 1 + (input2.limit ?? DEFAULT_LINES)).map((line, i) => `${first2 + i}	${cut(line, MAX_LINE_CHARS)}`);
+      const last = first2 + shown.length - 1;
+      return `lines ${first2}-${last} of ${lines.length}
 ${cut(shown.join("\n"), MAX_READ_CHARS)}`;
     }),
     /** A folder's entries, folders first, each folder ending in `/`. */
@@ -66409,9 +66563,9 @@ function createServer2(root, sessions, version22, level) {
     server.registerTool(
       "write_stdin",
       {
-        description: "Types into a running command and returns what it wrote since. With no chars, waits and returns what it has written. A Ctrl-C character (\\u0003) interrupts it; Ctrl-D (\\u0004) ends its input.",
+        description: "Types into a running command and returns what it wrote since. With no chars, waits and returns what it has written. A Ctrl-C character (\\u0003) interrupts it; Ctrl-D (\\u0004) ends its input. It also reaches a shell a person opened, by its id from list_sessions: there these are keys, what you type joins anything already typed, and Ctrl-D at its prompt closes it. Once an answer has given a session's exit code, that session is refused.",
         inputSchema: {
-          session_id: external_exports.string().min(1).describe("From exec_command's answer."),
+          session_id: external_exports.string().min(1).describe("From exec_command's answer, or list_sessions."),
           chars: external_exports.string().optional().describe("What to type; include \\n to press Enter."),
           yield_time_ms: YieldTime.describe(
             "How long to wait: with chars 250 to 30000, by default 250; with none 5000 to 30000."
@@ -66423,6 +66577,28 @@ function createServer2(root, sessions, version22, level) {
       },
       (input2) => answering(() => sessions.write(input2))
     );
+    server.registerTool(
+      "list_sessions",
+      {
+        description: "Lists the sessions here, running or lately ended: each command exec_command started, and each shell a person opened. Gives each one's session_id for write_stdin, who started it, since when, its exit code and the start of its command.",
+        outputSchema: {
+          sessions: external_exports.array(
+            external_exports.object({
+              session_id: external_exports.string(),
+              started_by: external_exports.enum(["agent", "person"]).describe("A person's is their own shell."),
+              since: external_exports.string().describe("When it started."),
+              exit_code: external_exports.number().nullable().describe("Null while it is still running."),
+              cmd: external_exports.string().describe("Its first line, or the start of it.")
+            })
+          )
+        },
+        annotations: READ_ONLY
+      },
+      () => {
+        const listed = listing(sessions.list());
+        return { ...text(formatSessions(listed)), structuredContent: { sessions: listed } };
+      }
+    );
   }
   server.registerTool(
     "read",
@@ -66478,18 +66654,22 @@ function createServer2(root, sessions, version22, level) {
     );
   return server;
 }
-var VERSION = "0.0.4";
+var VERSION = "0.0.5";
 function createAgentExec(options) {
   const root = realpathSync(resolve3(options.workspace));
   const level = options.level ?? "read";
   const listeners = /* @__PURE__ */ new Set();
-  const sessions = new Sessions(root, (event) => {
-    for (const listener of listeners)
-      try {
-        listener(event);
-      } catch {
-      }
-  });
+  const sessions = new Sessions(
+    root,
+    (event) => {
+      for (const listener of listeners)
+        try {
+          listener(event);
+        } catch {
+        }
+    },
+    options.pty
+  );
   const host = createHostFiles(root, level);
   return {
     async handle(request, response, body) {
@@ -66507,6 +66687,16 @@ function createAgentExec(options) {
       return () => void listeners.delete(listener);
     },
     files: host.files,
+    terminals: {
+      list: () => sessions.list(),
+      open({ columns, rows }) {
+        if (level !== "terminal") throw new Error("A shell needs the terminal level.");
+        return sessions.open(columns, rows);
+      },
+      write: (id, text22) => sessions.type(id, text22),
+      resize: (id, columns, rows) => sessions.resize(id, columns, rows),
+      stop: (id) => sessions.stop(id)
+    },
     async close() {
       await Promise.all([sessions.stopAll(), host.close()]);
     }
@@ -66927,11 +67117,6 @@ var BrowserLive = class {
   }
 };
 
-// src/live.ts
-import { chmodSync, existsSync, statSync as statSync2 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname3, join as join5 } from "node:path";
-
 // node_modules/ws/wrapper.mjs
 var import_stream2 = __toESM(require_stream(), 1);
 var import_extension = __toESM(require_extension(), 1);
@@ -67109,183 +67294,263 @@ var FilesLive = class {
   }
 };
 
+// src/text.ts
+var MAX_TEXT = 1e4;
+function* pieces(text3, most = MAX_TEXT) {
+  for (let from = 0; from < text3.length; ) {
+    let to = Math.min(from + most, text3.length);
+    const last = text3.charCodeAt(to - 1);
+    if (to < text3.length && last >= 55296 && last <= 56319) to -= 1;
+    yield text3.slice(from, to);
+    from = to;
+  }
+}
+
 // src/live.ts
 var PROTOCOLS = {
-  commands: "commands@1",
-  terminal: "pty@1",
+  terminal: "terminal@1",
   files: "files@1",
-  browser: "screencast@1"
+  browser: "screencast@1",
+  load: "metrics@1"
 };
-var MAX_EVENTS = 2e3;
-var MAX_SCROLLBACK = 64 * 1024;
-var OUTPUT = 48;
-var INPUT = 48;
-var RESIZE = 49;
-var sockets = new import_websocket_server.default({ noServer: true });
-var fileSockets = new import_websocket_server.default({ noServer: true, maxPayload: MAX_PART });
-var pty;
-var loadPty = () => {
-  pty ??= (async () => {
-    const require3 = createRequire3(import.meta.url);
-    let loaded2;
-    try {
-      loaded2 = require3("node-pty");
-    } catch {
-      return "The terminal needs node-pty, which isn't installed with this service.";
-    }
-    const root = dirname3(require3.resolve("node-pty/package.json"));
-    for (const helper of [
-      join5(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
-      join5(root, "build", "Release", "spawn-helper")
-    ])
-      try {
-        if (existsSync(helper) && (statSync2(helper).mode & 73) === 0) chmodSync(helper, 493);
-      } catch {
-        return `The terminal needs ${helper} to be executable, and it isn't.`;
-      }
-    return loaded2;
-  })();
-  return pty;
+var MAX_MESSAGE = 64 * 1024;
+var MAX_BUFFERED3 = 4 * 1024 * 1024;
+var deliver = (ws, message) => {
+  if (ws.bufferedAmount > MAX_BUFFERED3) ws.terminate();
+  else ws.send(JSON.stringify(message));
+};
+var MAX_CMD = 8e3;
+var MAX_WORKDIR = 2e3;
+var SERVERS = {
+  terminal: new import_websocket_server.default({ noServer: true, maxPayload: MAX_MESSAGE }),
+  files: new import_websocket_server.default({ noServer: true, maxPayload: MAX_PART }),
+  browser: new import_websocket_server.default({ noServer: true }),
+  load: new import_websocket_server.default({ noServer: true, maxPayload: MAX_MESSAGE })
+};
+var MALFORMED = "That isn't a terminal@1 message.";
+var first = (text3, most) => {
+  const [head = ""] = pieces(text3, most);
+  return head;
 };
+function* messages(event) {
+  if (event.type === "start")
+    yield { ...event, cmd: first(event.cmd, MAX_CMD), workdir: first(event.workdir, MAX_WORKDIR) };
+  else if (event.type === "exit") yield event;
+  else for (const text3 of pieces(event.text)) yield { ...event, text: text3 };
+}
 var Live = class {
-  #workspace;
-  #terminal;
-  #events = [];
-  #watchers = /* @__PURE__ */ new Set();
-  #shells = /* @__PURE__ */ new Map();
-  #shell;
-  #scrollback = "";
+  #terminals;
+  #viewers = /* @__PURE__ */ new Set();
   #browser;
   #files;
   /** Whether a person may write files here: not where the agent can only read them. */
   #writes;
-  constructor(exec, workspace, access, browser) {
-    this.#workspace = workspace;
-    this.#terminal = access === "terminal" && exec !== void 0;
+  #load;
+  constructor(exec, access, load, browser) {
+    this.#load = load;
+    if (exec && access === "terminal") {
+      this.#terminals = exec.terminals;
+      exec.onCommand((event) => {
+        for (const message of messages(event)) for (const ws of this.#viewers) deliver(ws, message);
+      });
+    }
     this.#files = exec && new FilesLive(exec.files);
     this.#writes = access !== "read";
     this.#browser = browser;
-    exec?.onCommand((event) => this.#heard(event));
   }
-  async surfaces() {
+  surfaces() {
     const surfaces = [];
-    if (this.#terminal) {
-      const loaded2 = await loadPty();
-      surfaces.push(
-        { surface: "commands", protocol: PROTOCOLS.commands, operate: false },
-        {
-          surface: "terminal",
-          protocol: PROTOCOLS.terminal,
-          operate: true,
-          ...typeof loaded2 === "string" ? { unavailable: loaded2 } : {}
-        }
-      );
-    }
+    if (this.#terminals)
+      surfaces.push({ surface: "terminal", protocol: PROTOCOLS.terminal, operate: true });
     if (this.#files)
       surfaces.push({ surface: "files", protocol: PROTOCOLS.files, operate: this.#writes });
     if (this.#browser)
       surfaces.push({ surface: "browser", protocol: PROTOCOLS.browser, operate: true });
+    surfaces.push({ surface: "load", protocol: PROTOCOLS.load, operate: false });
     return surfaces;
   }
   /** Take an upgraded request as a socket on one surface. */
   open(surface, mode, request, socket, head) {
     socket.on("error", () => socket.destroy());
-    const server = surface === "files" ? fileSockets : sockets;
-    server.handleUpgrade(request, socket, head, (ws) => {
+    SERVERS[surface].handleUpgrade(request, socket, head, (ws) => {
       ws.on("error", () => ws.terminate());
-      if (surface === "commands") this.#watch(ws);
+      if (surface === "terminal" && this.#terminals) this.#view(ws, mode, this.#terminals);
       else if (surface === "files" && this.#files) this.#files.open(ws, mode);
       else if (surface === "browser" && this.#browser) this.#browser.open(ws, mode);
-      else if (surface === "terminal") this.#attach(ws, mode).catch(() => ws.terminate());
+      else if (surface === "load") this.#load.open(ws);
       else ws.close(1011, `There's no ${surface} here.`);
     });
   }
+  /** The terminals themselves end with the AgentExec that runs them. */
   close() {
     void this.#browser?.close();
     this.#files?.close();
-    for (const ws of [...this.#watchers, ...this.#shells.keys()]) ws.close(1001, "It stopped.");
-    this.#shell?.kill();
-    this.#shell = void 0;
-  }
-  #heard(event) {
-    this.#events.push(event);
-    if (this.#events.length > MAX_EVENTS) this.#events.splice(0, this.#events.length - MAX_EVENTS);
-    const message = JSON.stringify(event);
-    for (const ws of this.#watchers) ws.send(message);
-  }
-  /** commands@1: each event as a JSON message, those before it first. Nothing comes back. */
-  #watch(ws) {
-    for (const event of this.#events) ws.send(JSON.stringify(event));
-    this.#watchers.add(ws);
-    ws.on("close", () => this.#watchers.delete(ws));
-  }
-  /** pty@1: one shell for the computer, shared by every socket on it. */
-  async #attach(ws, mode) {
-    const loaded2 = await loadPty();
-    if (typeof loaded2 === "string") return ws.close(1011, loaded2);
-    if (!this.#shell) {
-      this.#scrollback = "";
-      let shell;
+    this.#load.close();
+    for (const ws of this.#viewers) ws.close(1001, "It stopped.");
+  }
+  /**
+   * terminal@1: every terminal on one socket. Those already here come first, each with the end of
+   * what it wrote, and then each event as it happens. Listing and joining are one step, so nothing
+   * falls between them.
+   */
+  #view(ws, mode, terminals) {
+    for (const { id, by, cmd, workdir, tty, at, output: output2, exitCode, endedAt } of terminals.list()) {
+      const events = [{ type: "start", id, by, cmd, workdir, tty, at }];
+      if (output2) events.push({ type: "output", id, text: output2 });
+      if (exitCode !== void 0 && endedAt)
+        events.push({ type: "exit", id, exitCode, at: endedAt });
+      for (const event of events)
+        for (const message of messages(event)) ws.send(JSON.stringify(message));
+    }
+    this.#viewers.add(ws);
+    ws.on("close", () => this.#viewers.delete(ws));
+    if (mode !== "operate") return;
+    const refuse = (why) => deliver(ws, { type: "refused", message: reason2(why) });
+    ws.on("message", (data) => {
       try {
-        shell = loaded2.spawn(process.env.SHELL || "/bin/bash", ["-l"], {
-          name: "xterm-256color",
-          cols: 80,
-          rows: 24,
-          cwd: this.#workspace,
-          env: process.env
-        });
+        const sent = JSON.parse(data.toString()) ?? {};
+        const { type, id, text: text3 } = sent;
+        const [columns, rows] = [sent.columns, sent.rows];
+        if (type === "open") terminals.open({ columns, rows });
+        else if (typeof id !== "string") throw new Error(MALFORMED);
+        else if (type === "input" && typeof text3 === "string") terminals.write(id, text3);
+        else if (type === "resize") terminals.resize(id, columns, rows);
+        else if (type === "stop") terminals.stop(id).catch(refuse);
+        else throw new Error(MALFORMED);
       } catch (error62) {
-        return ws.close(1011, `The shell didn't start: ${String(error62)}`.slice(0, 120));
+        refuse(error62 instanceof SyntaxError ? MALFORMED : error62);
       }
-      shell.onData((data) => {
-        this.#scrollback = (this.#scrollback + data).slice(-MAX_SCROLLBACK);
-        const frame = Buffer.concat([Buffer.from([OUTPUT]), Buffer.from(data)]);
-        for (const client of this.#shells.keys()) client.send(frame);
-      });
-      shell.onExit(() => {
-        if (this.#shell !== shell) return;
-        this.#shell = void 0;
-        for (const client of this.#shells.keys()) client.close(1e3, "The shell exited.");
-      });
-      this.#shell = shell;
-    }
-    if (this.#scrollback)
-      ws.send(Buffer.concat([Buffer.from([OUTPUT]), Buffer.from(this.#scrollback)]));
-    this.#shells.set(ws, mode);
-    ws.on("close", () => this.#shells.delete(ws));
-    ws.on("message", (data, binary) => {
-      const frame = binary ? data : Buffer.from(data);
-      if (mode !== "operate" || frame.length === 0 || !this.#shell) return;
-      if (frame[0] === INPUT) this.#shell.write(frame.subarray(1).toString());
-      else if (frame[0] === RESIZE)
-        try {
-          const { columns, rows } = JSON.parse(frame.subarray(1).toString());
-          if (columns > 0 && rows > 0) this.#shell.resize(Math.floor(columns), Math.floor(rows));
-        } catch {
-        }
     });
   }
 };
 
+// src/load-live.ts
+import { execFile } from "node:child_process";
+import { readFile as readFile2 } from "node:fs/promises";
+import { availableParallelism, cpus, freemem, totalmem } from "node:os";
+import { promisify } from "node:util";
+var EVERY_MS = 2e3;
+var run = promisify(execFile);
+var numberOf = (text3, name) => Number(new RegExp(`^${name}\\s+(\\d+)`, "m").exec(text3)?.[1]);
+async function disk(folder) {
+  const { stdout } = await run("df", ["-kP", folder], { timeout: EVERY_MS });
+  const [, total, used] = /\s(\d+)\s+(\d+)\s+\d+\s+\d+%/.exec(stdout) ?? [];
+  if (!total) throw new Error("No disk.");
+  return { diskUsed: Number(used) * 1024, diskTotal: Number(total) * 1024 };
+}
+async function machine() {
+  const cpu = { used: 0, total: 0 };
+  for (const { times } of cpus()) {
+    cpu.used += times.user + times.nice + times.sys + times.irq;
+    cpu.total += times.user + times.nice + times.sys + times.irq + times.idle;
+  }
+  if (process.platform !== "darwin")
+    return { scope: "machine", cpu, memUsed: totalmem() - freemem() };
+  const { stdout } = await run("/usr/bin/vm_stat", { timeout: EVERY_MS });
+  const pages = numberOf(stdout, "Pages active:") + numberOf(stdout, "Pages wired down:") + numberOf(stdout, "Pages occupied by compressor:");
+  return { scope: "machine", cpu, memUsed: pages * Number(/page size of (\d+)/.exec(stdout)?.[1]) };
+}
+async function cgroup() {
+  const read = (file2) => readFile2(`/sys/fs/cgroup/${file2}`, "utf8");
+  const [cpu, current, memory] = await Promise.all([
+    read("cpu.stat"),
+    read("memory.current"),
+    read("memory.stat")
+  ]);
+  return {
+    scope: "computer",
+    // No container has a limit, so the time there was is every CPU's.
+    cpu: {
+      used: numberOf(cpu, "usage_usec"),
+      total: performance.now() * 1e3 * availableParallelism()
+    },
+    // Less the files it has read and no longer uses, as `docker stats` counts it.
+    memUsed: Number(current) - numberOf(memory, "inactive_file")
+  };
+}
+var LoadLive = class {
+  #folder;
+  #contained;
+  #sockets = /* @__PURE__ */ new Set();
+  #timer;
+  #reading = false;
+  #before;
+  #last;
+  /**
+   * `folder` is on the disk that is reported. `contained` is whether the processes here are one
+   * computer's and nothing else's, as they are inside a container.
+   */
+  constructor(folder, contained) {
+    this.#folder = folder;
+    this.#contained = contained;
+  }
+  /** metrics@1: a reading every two seconds, the last one at once. What it sends is dropped. */
+  open(ws) {
+    this.#sockets.add(ws);
+    if (this.#last) ws.send(this.#last);
+    ws.on("close", () => {
+      this.#sockets.delete(ws);
+      if (this.#sockets.size === 0) this.close();
+    });
+    if (this.#timer) return;
+    this.#timer = setInterval(() => void this.#read(), EVERY_MS);
+    void this.#read();
+  }
+  close() {
+    clearInterval(this.#timer);
+    this.#timer = this.#before = this.#last = void 0;
+    for (const ws of this.#sockets) ws.close(1001, "It stopped.");
+  }
+  /** One at a time, and for the watching it began under: a reading taken too late is left. */
+  async #read() {
+    const timer = this.#timer;
+    if (this.#reading) return;
+    this.#reading = true;
+    try {
+      const sample = await (this.#contained ? cgroup().catch(machine) : machine());
+      const volume = await disk(this.#folder);
+      if (this.#timer !== timer) return;
+      const before = this.#before;
+      this.#before = sample.cpu;
+      if (!before) return;
+      const share = (sample.cpu.used - before.used) / (sample.cpu.total - before.total) || 0;
+      const reading = {
+        type: "reading",
+        scope: sample.scope,
+        cpuUsedPct: Math.round(Math.min(Math.max(share, 0), 1) * 1e3) / 10,
+        memUsed: sample.memUsed,
+        memTotal: totalmem(),
+        ...volume
+      };
+      if (!Number.isFinite(reading.cpuUsedPct + reading.memUsed)) return;
+      this.#last = JSON.stringify(reading);
+      for (const ws of this.#sockets) if (ws.bufferedAmount === 0) ws.send(this.#last);
+    } catch {
+    } finally {
+      this.#reading = false;
+    }
+  }
+};
+
 // src/store.ts
 import { createHash, randomBytes as randomBytes4, timingSafeEqual } from "node:crypto";
-import { chmodSync as chmodSync2, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
-import { join as join6 } from "node:path";
+import { chmodSync, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
+import { join as join5 } from "node:path";
 var newToken = () => randomBytes4(32).toString("base64url");
 var digestOf = (token) => createHash("sha256").update(token).digest("hex");
 var sameToken = (token, digest) => timingSafeEqual(Buffer.from(digestOf(token), "hex"), Buffer.from(digest, "hex"));
 function writePrivate(file2, text3) {
   writeFileSync(`${file2}.tmp`, text3, { mode: 384, flush: true });
   renameSync(`${file2}.tmp`, file2);
-  chmodSync2(file2, 384);
+  chmodSync(file2, 384);
 }
 var privateFolder = (dir) => {
   mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync2(dir, 448);
+  chmodSync(dir, 448);
   return dir;
 };
 function controlToken(data) {
-  const file2 = join6(data, "control-token");
+  const file2 = join5(data, "control-token");
   try {
     return readFileSync2(file2, "utf8").trim();
   } catch (error62) {
@@ -67305,11 +67570,41 @@ var ApiError = class extends Error {
     this.status = status;
   }
 };
+var pty;
+var loadPty = () => {
+  pty ??= (async () => {
+    const fails = (why) => () => {
+      throw new Error(why);
+    };
+    const require3 = createRequire3(import.meta.url);
+    let loaded2;
+    try {
+      loaded2 = require3("node-pty");
+    } catch {
+      return fails("node-pty isn't installed with this service.");
+    }
+    const root = dirname3(require3.resolve("node-pty/package.json"));
+    for (const helper of [
+      join6(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
+      join6(root, "build", "Release", "spawn-helper")
+    ])
+      try {
+        if (existsSync(helper) && (statSync2(helper).mode & 73) === 0) chmodSync2(helper, 493);
+      } catch {
+        return fails(`${helper} has to be executable, and it isn't.`);
+      }
+    return loaded2.spawn;
+  })();
+  return pty;
+};
 var ProcessRuntime = class {
   isolation = "none";
   #config;
-  constructor(config3) {
+  #contained;
+  /** `contained` is for inside a container, where load is the computer's own. */
+  constructor(config3, contained = false) {
     this.#config = config3;
+    this.#contained = contained;
   }
   async prepare() {
   }
@@ -67320,11 +67615,15 @@ var ProcessRuntime = class {
   async start(spec, folder, events) {
     let exec;
     if (spec.access !== "none")
-      exec = createAgentExec({ workspace: spec.workspace, level: spec.access });
+      exec = createAgentExec({
+        workspace: spec.workspace,
+        level: spec.access,
+        pty: await loadPty()
+      });
     let browser;
     let browserDown = false;
     if (spec.browser) {
-      const own3 = privateFolder(join7(folder, "browser"));
+      const own3 = privateFolder(join6(folder, "browser"));
       browser = new Browser(
         this.#config,
         own3,
@@ -67348,8 +67647,9 @@ var ProcessRuntime = class {
       browserLive = new BrowserLive(browser.endpoint);
       browser.gate = browserLive;
     }
-    const live = new Live(exec, spec.workspace, spec.access, browserLive);
-    const surfaces = await live.surfaces();
+    const load = new LoadLive(spec.workspace ?? folder, this.#contained);
+    const live = new Live(exec, spec.access, load, browserLive);
+    const surfaces = live.surfaces();
     return {
       browserTools: browser?.tools ?? [],
       /** As they are now: a browser that has stopped can't be opened, and says so. */
@@ -67384,13 +67684,13 @@ async function serveInside(options) {
   if (!token) throw new Error(`${INNER_TOKEN_VARIABLE} is not set.`);
   delete process.env[INNER_TOKEN_VARIABLE];
   const digest = digestOf(token);
-  const running = new ProcessRuntime({ path: BROWSER, sandbox: false }).start(
+  const running = new ProcessRuntime({ path: BROWSER, sandbox: false }, true).start(
     {
       id: "inside",
       ...options,
       ...options.access === "none" ? {} : { workspace: "/workspace" }
     },
-    privateFolder(join8(homedir(), ".agentcomputer")),
+    privateFolder(join7(homedir(), ".agentcomputer")),
     {
       log: (line) => process.stdout.write(`${line}
 `),
@@ -67425,7 +67725,7 @@ async function serveInside(options) {
     socket.on("error", () => socket.destroy());
     const given = /^Bearer (\S+)$/.exec(request.headers.authorization ?? "")?.[1];
     const url3 = new URL(request.url ?? "/", "http://localhost");
-    const surface = /^\/live\/(commands|terminal|files|browser)$/.exec(url3.pathname)?.[1];
+    const surface = /^\/live\/(terminal|files|browser|load)$/.exec(url3.pathname)?.[1];
     const mode = url3.searchParams.get("mode");
     if (!given || !sameToken(given, digest) || !surface || mode !== "watch" && mode !== "operate")
       return void socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
@@ -67440,7 +67740,7 @@ async function serveInside(options) {
 }
 
 // src/container.ts
-var run = promisify(execFile);
+var run2 = promisify2(execFile2);
 var START_MS2 = 6e4;
 var STOP_SECONDS = "5";
 var NOT_FORWARDED = /* @__PURE__ */ new Set([
@@ -67454,7 +67754,7 @@ var NOT_FORWARDED = /* @__PURE__ */ new Set([
 ]);
 async function docker(args, env = process.env) {
   try {
-    return (await run("docker", args, { env, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
+    return (await run2("docker", args, { env, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
   } catch (error62) {
     const { stderr, message } = error62;
     throw new Error(stderr?.trim() || message);
@@ -67533,7 +67833,7 @@ var ContainerRuntime = class {
   }
   /** The token between the service and this container, which a restart has to find again. */
   #tokenIn(folder) {
-    const file2 = join9(folder, "inner-token");
+    const file2 = join8(folder, "inner-token");
     try {
       return readFileSync3(file2, "utf8");
     } catch {
@@ -67672,7 +67972,7 @@ async function forward(url3, authorization, request, response) {
 }
 
 // src/handlers.ts
-var VERSION2 = "0.0.8";
+var VERSION2 = "0.0.10";
 function createHandlers(computers) {
   return {
     getInfo: async () => ({ version: VERSION2, isolation: computers.isolation }),
@@ -68254,32 +68554,30 @@ async function openLive(session, onMessage) {
   ws.addEventListener("message", (event) => onMessage(event.data));
   return { ws, closed };
 }
-var INPUT2 = 48;
-var RESIZE2 = 49;
-var Pty = class {
+var Terminals = class {
   #open;
   constructor(open4) {
     this.#open = open4;
   }
-  /** Attach to its shell, starting one if none is running. Every attachment shares it. */
+  /**
+   * Each terminal as it starts, writes and exits: those already there first, each with the end of
+   * what it wrote. Operating, the default, can also open a shell and act on any of them.
+   */
   async connect(opts) {
-    const mode = opts.mode ?? "operate";
-    const decoder = new TextDecoder();
-    const { ws, closed } = await openLive(await this.#open("terminal", mode), (data) => {
-      if (typeof data === "string") return;
-      const frame = new Uint8Array(data);
-      if (frame[0] === INPUT2) opts.onData(decoder.decode(frame.subarray(1), { stream: true }));
-    });
-    const send2 = (type, text3) => {
-      const body = new TextEncoder().encode(text3);
-      const frame = new Uint8Array(body.length + 1);
-      frame[0] = type;
-      frame.set(body, 1);
-      ws.send(frame);
-    };
+    const { ws, closed } = await openLive(
+      await this.#open("terminal", opts.mode ?? "operate"),
+      (data) => {
+        if (typeof data === "string") opts.onEvent(JSON.parse(data));
+      }
+    );
+    const send2 = (input2) => ws.send(JSON.stringify(input2));
     return {
-      sendInput: (data) => send2(INPUT2, data),
-      resize: (columns, rows) => send2(RESIZE2, JSON.stringify({ columns, rows })),
+      openShell: (columns, rows) => send2({ type: "open", columns, rows }),
+      sendInput: (id, text3) => {
+        for (const piece of pieces(text3)) send2({ type: "input", id, text: piece });
+      },
+      resize: (id, columns, rows) => send2({ type: "resize", id, columns, rows }),
+      stop: (id) => send2({ type: "stop", id }),
       close: () => ws.close(),
       closed
     };
@@ -68287,17 +68585,8 @@ var Pty = class {
 };
 var Commands = class {
   #endpoint;
-  #open;
-  constructor(endpoint, open4) {
+  constructor(endpoint) {
     this.#endpoint = endpoint;
-    this.#open = open4;
-  }
-  /** Each of the agent's commands as it runs: the ones already heard first, then as they come. */
-  async watch(onEvent) {
-    const { ws, closed } = await openLive(await this.#open("commands", "watch"), (data) => {
-      if (typeof data === "string") onEvent(JSON.parse(data));
-    });
-    return { close: () => ws.close(), closed };
   }
   async run(cmd, opts = {}) {
     let answer = await this.#endpoint.command("exec_command", {
@@ -68374,7 +68663,7 @@ var Computer = class _Computer {
   computerID;
   commands;
   files;
-  pty;
+  terminals;
   #connection;
   #token;
   #computer;
@@ -68385,9 +68674,8 @@ var Computer = class _Computer {
     this.#token = token;
     this.#urls = info.endpoints;
     this.#computer = new Endpoint(info.endpoints.computer, token);
-    const open4 = (surface, mode) => this.liveSession(surface, mode);
-    this.commands = new Commands(this.#computer, open4);
-    this.pty = new Pty(open4);
+    this.commands = new Commands(this.#computer);
+    this.terminals = new Terminals((surface, mode) => this.liveSession(surface, mode));
     this.files = new Files(this.#computer);
   }
   static async create(opts) {
@@ -68508,7 +68796,7 @@ import {
   STATUS_CODES as STATUS_CODES3
 } from "node:http";
 import { createServer as createTlsServer } from "node:https";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 
 // node_modules/@modelcontextprotocol/server/dist/chunk-vYduTEsO.mjs
 var __create4 = Object.create;
@@ -75942,8 +76230,8 @@ var require_utils3 = /* @__PURE__ */ __commonJSMin3(((exports, module) => {
     }
     if (bestLength < 2) return hextets.join(":");
     const head = hextets.slice(0, bestStart).join(":");
-    const tail = hextets.slice(bestStart + bestLength).join(":");
-    return head + "::" + tail;
+    const tail2 = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail2;
   }
   function normalizeIPv6Address(input2) {
     const compression = input2.indexOf("::");
@@ -82420,9 +82708,9 @@ var WebStandardStreamableHTTPServerTransport2 = class {
       }
     });
   }
-  async _checkScopeChallenge(messages, authInfo) {
+  async _checkScopeChallenge(messages2, authInfo) {
     if (!this._scopeChallengeResolver) return;
-    const challenge = await findScopeChallenge2(messages.filter((message) => isJSONRPCRequest3(message)), authInfo, this._scopeChallengeResolver);
+    const challenge = await findScopeChallenge2(messages2.filter((message) => isJSONRPCRequest3(message)), authInfo, this._scopeChallengeResolver);
     return challenge === void 0 ? void 0 : createScopeChallengeResponse2(challenge, scopeChallengeResourceMetadataUrl2(authInfo));
   }
   /**
@@ -82720,21 +83008,21 @@ data:
         this.onerror?.(/* @__PURE__ */ new Error(`Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE2} messages`));
         return this.createJsonErrorResponse(400, -32600, `Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE2} messages`);
       }
-      let messages;
+      let messages2;
       try {
-        messages = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(rawMessage)];
+        messages2 = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(rawMessage)];
       } catch (error62) {
         this.onerror?.(error62);
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
       if (this._closed) return this.createJsonErrorResponse(404, -32001, "Session not found");
-      const isInitializationRequest = messages.some((element) => isInitializeRequest3(element));
+      const isInitializationRequest = messages2.some((element) => isInitializeRequest3(element));
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== void 0) {
           this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Server already initialized"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
         }
-        if (messages.length > 1) {
+        if (messages2.length > 1) {
           this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Only one initialization request is allowed"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
         }
@@ -82751,21 +83039,21 @@ data:
       if (this._closed) return this.createJsonErrorResponse(404, -32001, "Session not found");
       let scopeChallengeResponse;
       try {
-        scopeChallengeResponse = await this._checkScopeChallenge(messages, options?.authInfo);
+        scopeChallengeResponse = await this._checkScopeChallenge(messages2, options?.authInfo);
       } catch (error62) {
         this.onerror?.(error62);
         return this.createJsonErrorResponse(500, -32603, "Internal server error");
       }
       if (scopeChallengeResponse) return scopeChallengeResponse;
-      if (!messages.some((element) => isJSONRPCRequest3(element))) {
-        for (const message of messages) this.onmessage?.(message, {
+      if (!messages2.some((element) => isJSONRPCRequest3(element))) {
+        for (const message of messages2) this.onmessage?.(message, {
           authInfo: options?.authInfo,
           request
         });
         return new Response(null, { status: 202 });
       }
       const streamId = crypto.randomUUID();
-      const initRequest = messages.find((m) => isInitializeRequest3(m));
+      const initRequest = messages2.find((m) => isInitializeRequest3(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
       if (this._enableJsonResponse) return new Promise((resolve6) => {
         this._streamMapping.set(streamId, {
@@ -82774,8 +83062,8 @@ data:
             this._streamMapping.delete(streamId);
           }
         });
-        for (const message of messages) if (isJSONRPCRequest3(message)) this._requestToStreamMapping.set(message.id, streamId);
-        for (const message of messages) this.onmessage?.(message, {
+        for (const message of messages2) if (isJSONRPCRequest3(message)) this._requestToStreamMapping.set(message.id, streamId);
+        for (const message of messages2) this.onmessage?.(message, {
           authInfo: options?.authInfo,
           request
         });
@@ -82799,7 +83087,7 @@ data:
         "X-Accel-Buffering": "no"
       };
       if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-      for (const message of messages) if (isJSONRPCRequest3(message)) {
+      for (const message of messages2) if (isJSONRPCRequest3(message)) {
         this._streamMapping.set(streamId, {
           controller: streamController,
           encoder,
@@ -82815,7 +83103,7 @@ data:
         this._requestToStreamMapping.set(message.id, streamId);
       }
       await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
-      for (const message of messages) {
+      for (const message of messages2) {
         let closeSSEStream;
         let closeStandaloneSSEStream;
         if (isJSONRPCRequest3(message) && this._eventStore && this.supportsEmptySSEData(clientProtocolVersion)) {
@@ -84324,11 +84612,11 @@ var NodeStreamableHTTPServerTransport2 = class {
 // src/computers.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync3 } from "node:fs";
-import { isAbsolute, join as join10, resolve as resolve4 } from "node:path";
+import { isAbsolute, join as join9, resolve as resolve4 } from "node:path";
 var TOOLS = {
   read: ["read", "list", "search"],
   files: ["read", "list", "search", "edit"],
-  terminal: ["read", "list", "search", "edit", "exec_command", "write_stdin"]
+  terminal: ["read", "list", "search", "edit", "exec_command", "write_stdin", "list_sessions"]
 };
 var MAX_LOG = 256 * 1024;
 var MAX_TIMER_S = 2e6;
@@ -84346,7 +84634,7 @@ var Computers = class {
     this.#data = data;
     this.#base = base;
     this.#runtime = runtime;
-    this.#file = join10(data, "computers.json");
+    this.#file = join9(data, "computers.json");
     if (existsSync2(this.#file))
       for (const entry of JSON.parse(readFileSync4(this.#file, "utf8")))
         this.#stored.set(entry.id, entry);
@@ -84401,7 +84689,7 @@ var Computers = class {
       ...timeout === void 0 ? {} : { endAt: expiry(timeout) }
     };
     if (!workspace && access !== "none") {
-      stored.workspace = join10(this.#folder(id), "workspace");
+      stored.workspace = join9(this.#folder(id), "workspace");
       mkdirSync2(stored.workspace, { recursive: true, mode: 448 });
     }
     this.#stored.set(id, stored);
@@ -84552,10 +84840,10 @@ var Computers = class {
     return stored;
   }
   #folder(id) {
-    return privateFolder(join10(this.#data, "computers", id));
+    return privateFolder(join9(this.#data, "computers", id));
   }
   #logFile(id) {
-    return join10(this.#folder(id), "log");
+    return join9(this.#folder(id), "log");
   }
   #log(id, line) {
     if (!this.#stored.has(id)) return;
@@ -84647,7 +84935,7 @@ var OPENAPI = {
   "openapi": "3.1.0",
   "info": {
     "title": "AgentComputer",
-    "version": "0.0.8",
+    "version": "0.0.10",
     "description": "Computers for agents. This file is the source of truth: the HTTP API, the MCP control tools and the SDK are all generated from it. An operation with `x-mcp-tool` is also an MCP tool of that name.",
     "license": {
       "name": "Apache-2.0",
@@ -84968,7 +85256,7 @@ var OPENAPI = {
       "post": {
         "operationId": "createLiveSession",
         "x-mcp-tool": "computer_live",
-        "summary": "A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, a shell of your own, its files, or its browser. Open its url as a WebSocket within 60 seconds.",
+        "summary": "A one-time ticket to watch or operate one of its surfaces live: its terminals, its files, its browser, or its load. Open its url as a WebSocket within 60 seconds.",
         "requestBody": {
           "required": true,
           "content": {
@@ -85099,7 +85387,7 @@ var OPENAPI = {
           "files",
           "terminal"
         ],
-        "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+        "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
       },
       "ComputerState": {
         "type": "string",
@@ -85307,12 +85595,12 @@ var OPENAPI = {
       "Surface": {
         "type": "string",
         "enum": [
-          "commands",
           "terminal",
           "files",
-          "browser"
+          "browser",
+          "load"
         ],
-        "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
+        "description": "terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches."
       },
       "LiveMode": {
         "type": "string",
@@ -85755,6 +86043,266 @@ var OPENAPI = {
           }
         ]
       },
+      "TerminalEvent": {
+        "description": "What the service sends on a terminal@1 socket, as JSON text, no message over 65,536 bytes. A terminal is a command the agent started or a shell a person opened; its id is the session id the agent's tools use. A new socket is first sent, for each terminal already there, the oldest first, its start, the end of what it wrote (its last 65,536 characters), and its exit if it has ended; then each event as it happens, with nothing to mark where the first ends. The last 64 that ended are among those already there, and one that leaves that list is not told. A character here is a UTF-16 unit. A socket with more than 4 MiB still to be sent to it is closed, with no close frame (1006): one that has stopped reading, or one that is reading while a terminal writes tens of megabytes at once. It isn't an error. Opened again, it is sent every terminal afresh, with the last 65,536 characters each wrote, in place of whatever it held.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "A terminal began.",
+            "required": [
+              "type",
+              "id",
+              "by",
+              "cmd",
+              "workdir",
+              "tty",
+              "at"
+            ],
+            "properties": {
+              "type": {
+                "const": "start"
+              },
+              "id": {
+                "type": "string"
+              },
+              "by": {
+                "type": "string",
+                "enum": [
+                  "agent",
+                  "person"
+                ],
+                "description": "The way in it came: agent through a tool, person through this surface."
+              },
+              "cmd": {
+                "type": "string",
+                "description": "Its command, the first 8,000 characters of it."
+              },
+              "workdir": {
+                "type": "string",
+                "description": "Its folder, the first 2,000 characters of it."
+              },
+              "tty": {
+                "type": "boolean",
+                "description": "Whether it is on a terminal device, as a person's shell is. One that isn't, as the agent's commands aren't, echoes nothing typed into it and wants a line feed for Enter. Nothing tells the size of one that is."
+              },
+              "at": {
+                "type": "string",
+                "format": "date-time"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "What it wrote, as it writes: 10,000 characters a message at most, a longer piece as several. A command that left something running can still write after its exit.",
+            "required": [
+              "type",
+              "id",
+              "text"
+            ],
+            "properties": {
+              "type": {
+                "const": "output"
+              },
+              "id": {
+                "type": "string"
+              },
+              "stream": {
+                "type": "string",
+                "enum": [
+                  "stdout",
+                  "stderr"
+                ],
+                "description": "Left out for one on a terminal device, which has one stream, and in what a new socket is first sent, where the two are one text."
+              },
+              "text": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "It ended.",
+            "required": [
+              "type",
+              "id",
+              "exitCode",
+              "at"
+            ],
+            "properties": {
+              "type": {
+                "const": "exit"
+              },
+              "id": {
+                "type": "string"
+              },
+              "exitCode": {
+                "type": "integer"
+              },
+              "at": {
+                "type": "string",
+                "format": "date-time"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "What this socket asked wasn't done, and why, in words for a person. Sent only to the operate socket that asked. What was done is answered by its event, or by nothing.",
+            "required": [
+              "type",
+              "message"
+            ],
+            "properties": {
+              "type": {
+                "const": "refused"
+              },
+              "message": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      },
+      "TerminalInput": {
+        "description": "What an operate socket sends on terminal@1, as JSON text. One that can't be done, or that is none of these, is answered with refused. What a watch socket sends is dropped. A message over 65,536 bytes closes the socket, so a long text goes as several inputs.",
+        "oneOf": [
+          {
+            "type": "object",
+            "description": "Start a shell of your own in the workspace, as its user, on a terminal device of this size. It arrives as a start like any other. Refused past the 64 terminals that may run at once, and where the service has no node-pty.",
+            "required": [
+              "type",
+              "columns",
+              "rows"
+            ],
+            "properties": {
+              "type": {
+                "const": "open"
+              },
+              "columns": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 1e3
+              },
+              "rows": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 1e3
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "Type into a running terminal, the agent's included. In a command, Ctrl-C (U+0003) interrupts it and Ctrl-D (U+0004) ends its input. Refused for one that has ended or isn't there.",
+            "required": [
+              "type",
+              "id",
+              "text"
+            ],
+            "properties": {
+              "type": {
+                "const": "input"
+              },
+              "id": {
+                "type": "string"
+              },
+              "text": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "Give a terminal on a terminal device a new size, which is the size for everyone looking at it. Refused for a command, which has none, and for one that has ended or isn't there.",
+            "required": [
+              "type",
+              "id",
+              "columns",
+              "rows"
+            ],
+            "properties": {
+              "type": {
+                "const": "resize"
+              },
+              "id": {
+                "type": "string"
+              },
+              "columns": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 1e3
+              },
+              "rows": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 1e3
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "End a terminal: an interrupt for a command, a hangup for a shell, then a kill a second later. Its exit is the answer. One that has ended is left as it is, and one that isn't there is refused.",
+            "required": [
+              "type",
+              "id"
+            ],
+            "properties": {
+              "type": {
+                "const": "stop"
+              },
+              "id": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      },
+      "LoadReading": {
+        "description": "What the service sends on a metrics@1 socket, as JSON text. What a socket sends is dropped.",
+        "type": "object",
+        "required": [
+          "type",
+          "scope",
+          "cpuUsedPct",
+          "memUsed",
+          "memTotal",
+          "diskUsed",
+          "diskTotal"
+        ],
+        "properties": {
+          "type": {
+            "const": "reading"
+          },
+          "scope": {
+            "type": "string",
+            "enum": [
+              "computer",
+              "machine"
+            ],
+            "description": "Whose numbers these are. computer: this computer's own, which a container's are. machine: the whole machine's, which a computer with no isolation shares with whatever else runs there, so every computer of that service reads the same; and a container's where it can't read its own."
+          },
+          "cpuUsedPct": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 100,
+            "description": "Of all the machine's CPUs, since the reading before. One decimal."
+          },
+          "memUsed": {
+            "type": "integer",
+            "description": "Bytes in use."
+          },
+          "memTotal": {
+            "type": "integer",
+            "description": "Bytes the machine has: no computer has a limit."
+          },
+          "diskUsed": {
+            "type": "integer",
+            "description": "Bytes used on the volume its workspace is on, or its own folder where it has no workspace. The volume's, not the workspace's own size."
+          },
+          "diskTotal": {
+            "type": "integer",
+            "description": "Bytes on that volume."
+          }
+        }
+      },
       "FilesRequest": {
         "description": "What a socket sends on files@1, as JSON text. Each has an id of its own choosing, which the answer repeats; answers come as they are ready, in any order, and ids aren't checked for repeats. A request still unanswered when the socket closes gets no answer. A path is from the workspace, with / between its parts, or absolute inside it, and nothing outside the workspace is reached. A binary message that follows no write closes the socket, and so does any message over 1,048,576 bytes.",
         "oneOf": [
@@ -86224,7 +86772,7 @@ var OPERATIONS = [
               "files",
               "terminal"
             ],
-            "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+            "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
           },
           "browser": {
             "type": "boolean"
@@ -86313,7 +86861,7 @@ var OPERATIONS = [
             "files",
             "terminal"
           ],
-          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
         },
         "browser": {
           "type": "boolean",
@@ -86383,7 +86931,7 @@ var OPERATIONS = [
                 "files",
                 "terminal"
               ],
-              "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+              "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
             },
             "browser": {
               "type": "boolean"
@@ -86523,7 +87071,7 @@ var OPERATIONS = [
                 "files",
                 "terminal"
               ],
-              "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+              "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
             },
             "browser": {
               "type": "boolean"
@@ -86607,12 +87155,12 @@ var OPERATIONS = [
                   "surface": {
                     "type": "string",
                     "enum": [
-                      "commands",
                       "terminal",
                       "files",
-                      "browser"
+                      "browser",
+                      "load"
                     ],
-                    "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
+                    "description": "terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches."
                   },
                   "protocol": {
                     "type": "string"
@@ -86754,7 +87302,7 @@ var OPERATIONS = [
             "files",
             "terminal"
           ],
-          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
         },
         "browser": {
           "type": "boolean"
@@ -86878,7 +87426,7 @@ var OPERATIONS = [
             "files",
             "terminal"
           ],
-          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
         },
         "browser": {
           "type": "boolean"
@@ -87007,7 +87555,7 @@ var OPERATIONS = [
             "files",
             "terminal"
           ],
-          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden."
+          "description": "How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden."
         },
         "browser": {
           "type": "boolean"
@@ -87128,7 +87676,7 @@ var OPERATIONS = [
     "method": "POST",
     "path": "/v1/computers/{computerID}/live",
     "tool": "computer_live",
-    "summary": "A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, a shell of your own, its files, or its browser. Open its url as a WebSocket within 60 seconds.",
+    "summary": "A one-time ticket to watch or operate one of its surfaces live: its terminals, its files, its browser, or its load. Open its url as a WebSocket within 60 seconds.",
     "status": 201,
     "hasBody": true,
     "pathParameters": [
@@ -87147,12 +87695,12 @@ var OPERATIONS = [
         "surface": {
           "type": "string",
           "enum": [
-            "commands",
             "terminal",
             "files",
-            "browser"
+            "browser",
+            "load"
           ],
-          "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
+          "description": "terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches."
         },
         "mode": {
           "allOf": [
@@ -87194,12 +87742,12 @@ var OPERATIONS = [
         "surface": {
           "type": "string",
           "enum": [
-            "commands",
             "terminal",
             "files",
-            "browser"
+            "browser",
+            "load"
           ],
-          "description": "commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes."
+          "description": "terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches."
         },
         "mode": {
           "type": "string",
@@ -87305,7 +87853,7 @@ async function serve(options) {
     pattern: new RegExp(`^${operation.path.replace(/\{[^}]+\}/g, "([^/]+)")}$`),
     check: fromJsonSchema3(operation.input)
   }));
-  const run2 = async (route2, input2) => {
+  const run3 = async (route2, input2) => {
     const checked = await route2.check["~standard"].validate(input2);
     if (checked.issues)
       throw new ApiError(400, checked.issues.map((issue3) => issue3.message).join("; "));
@@ -87320,7 +87868,7 @@ async function serve(options) {
           { description: route2.operation.summary, inputSchema: route2.check },
           async (input2) => {
             try {
-              const output2 = await run2(route2, input2) ?? {};
+              const output2 = await run3(route2, input2) ?? {};
               return { content: [{ type: "text", text: JSON.stringify(output2) }] };
             } catch (error62) {
               if (!(error62 instanceof ApiError)) throw error62;
@@ -87372,7 +87920,7 @@ async function serve(options) {
         const value = url3.searchParams.get(name);
         if (value !== null) input2[name] = value;
       }
-      return send(response, operation.status, await run2(candidate, input2));
+      return send(response, operation.status, await run3(candidate, input2));
     }
     throw pathMatched ? new ApiError(405, "Not allowed.") : new ApiError(404, "Not found.");
   };
@@ -87419,7 +87967,7 @@ ${JSON.stringify({ code: status, message })}
   const scheme = options.tls ? "https" : "http";
   base = options.publicUrl?.replace(/\/+$/, "") ?? `${scheme}://${bound.family === "IPv6" ? `[${bound.address}]` : bound.address}:${bound.port}`;
   await computers.resume();
-  const record3 = join11(data, "server.json");
+  const record3 = join10(data, "server.json");
   writePrivate(
     record3,
     JSON.stringify({ url: base, pid: process.pid, isolation: options.runtime.isolation })
@@ -87459,7 +88007,7 @@ var USAGE = `Usage: agentcomputer <command> [--data DIR]
   stop <id>                         stop it, keeping its folder and token
   start <id> [--timeout SECONDS]    start a stopped computer again
   logs <id>                         what its servers wrote
-  live <id> --surface commands|terminal|files|browser [--mode watch|operate]
+  live <id> --surface terminal|files|browser|load [--mode watch|operate]
                                     a one-time ticket to open one live, as a WebSocket
   kill <id>                         stop it and remove what the service made
 
@@ -87472,13 +88020,13 @@ var UsageError = class extends Error {
 function dataFolder(given) {
   const xdg = process.env.XDG_DATA_HOME;
   return resolve5(
-    given ?? process.env.AGENTCOMPUTER_DATA ?? (xdg && isAbsolute2(xdg) ? join12(xdg, "agentcomputer") : join12(homedir2(), ".local", "share", "agentcomputer"))
+    given ?? process.env.AGENTCOMPUTER_DATA ?? (xdg && isAbsolute2(xdg) ? join11(xdg, "agentcomputer") : join11(homedir2(), ".local", "share", "agentcomputer"))
   );
 }
 function connectionTo(data) {
   try {
-    const { url: url3 } = JSON.parse(readFileSync6(join12(data, "server.json"), "utf8"));
-    return { apiUrl: url3, apiKey: readFileSync6(join12(data, "control-token"), "utf8").trim() };
+    const { url: url3 } = JSON.parse(readFileSync6(join11(data, "server.json"), "utf8"));
+    return { apiUrl: url3, apiKey: readFileSync6(join11(data, "control-token"), "utf8").trim() };
   } catch {
     throw new Error(
       `No service is running with its data in ${data}. Start one: agentcomputer serve`