@perkos/perkos-a2a 0.12.66 → 0.12.68

package/dist/index.js

@@ -16881,11 +16881,11 @@ var require_parse = __commonJS({
         segments[segments.length] = parent;
       }
       var n = key.length;
-      var open2 = first;
+      var open3 = first;
       var collected = 0;
-      while (open2 >= 0 && collected < options.depth) {
+      while (open3 >= 0 && collected < options.depth) {
         var level = 1;
-        var i = open2 + 1;
+        var i = open3 + 1;
         var close = -1;
         while (i < n && close < 0) {
           var cu = key.charCodeAt(i);
@@ -16900,23 +16900,23 @@ var require_parse = __commonJS({
           i += 1;
         }
         if (close < 0) {
-          segments[segments.length] = "[" + key.slice(open2) + "]";
+          segments[segments.length] = "[" + key.slice(open3) + "]";
           return segments;
         }
-        var seg = key.slice(open2, close + 1);
+        var seg = key.slice(open3, close + 1);
         var content = seg.slice(1, -1);
         if (!options.plainObjects && has.call(Object.prototype, content) && !options.allowPrototypes) {
           return;
         }
         segments[segments.length] = seg;
         collected += 1;
-        open2 = key.indexOf("[", close + 1);
+        open3 = key.indexOf("[", close + 1);
       }
-      if (open2 >= 0) {
+      if (open3 >= 0) {
         if (options.strictDepth === true) {
           throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
         }
-        segments[segments.length] = "[" + key.slice(open2) + "]";
+        segments[segments.length] = "[" + key.slice(open3) + "]";
       }
       return segments;
     };
@@ -18441,10 +18441,10 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path = __require("path");
     var fs = __require("fs");
-    var dirname5 = path.dirname;
+    var dirname6 = path.dirname;
     var basename = path.basename;
     var extname = path.extname;
-    var join5 = path.join;
+    var join8 = path.join;
     var resolve4 = path.resolve;
     module.exports = View;
     function View(name, options) {
@@ -18480,7 +18480,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path2; i++) {
         var root = roots[i];
         var loc = resolve4(root, name);
-        var dir = dirname5(loc);
+        var dir = dirname6(loc);
         var file = basename(loc);
         path2 = this.resolve(dir, file);
       }
@@ -18492,12 +18492,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve5(dir, file) {
       var ext = this.ext;
-      var path2 = join5(dir, file);
+      var path2 = join8(dir, file);
       var stat = tryStat(path2);
       if (stat && stat.isFile()) {
         return path2;
       }
-      path2 = join5(dir, basename(file, ext), "index" + ext);
+      path2 = join8(dir, basename(file, ext), "index" + ext);
       stat = tryStat(path2);
       if (stat && stat.isFile()) {
         return path2;
@@ -19130,7 +19130,7 @@ var require_send = __commonJS({
     var Stream = __require("stream");
     var util = __require("util");
     var extname = path.extname;
-    var join5 = path.join;
+    var join8 = path.join;
     var normalize = path.normalize;
     var resolve4 = path.resolve;
     var sep = path.sep;
@@ -19349,7 +19349,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = path2.split(sep);
-        path2 = normalize(join5(root, path2));
+        path2 = normalize(join8(root, path2));
       } else {
         if (UP_PATH_REGEXP.test(path2)) {
           debug('malicious path "%s"', path2);
@@ -19484,7 +19484,7 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join5(path2, self._index[i]);
+        var p = join8(path2, self._index[i]);
         debug('stat "%s"', p);
         fs.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -21908,7 +21908,7 @@ var require_response = __commonJS({
     var encodeUrl = require_encodeurl();
     var escapeHtml = require_escape_html();
     var http = __require("http");
-    var isAbsolute = require_utils2().isAbsolute;
+    var isAbsolute2 = require_utils2().isAbsolute;
     var onFinished = require_on_finished();
     var path = __require("path");
     var statuses = require_statuses();
@@ -22114,7 +22114,7 @@ var require_response = __commonJS({
         done = options;
         opts = {};
       }
-      if (!opts.root && !isAbsolute(path2)) {
+      if (!opts.root && !isAbsolute2(path2)) {
         throw new TypeError("path must be absolute or specify root to res.sendFile");
       }
       var pathname = encodeURI(path2);
@@ -24860,7 +24860,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash4 } = __require("crypto");
+    var { randomBytes, createHash: createHash5 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -25528,7 +25528,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -25809,7 +25809,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          ws.once("open", function open3() {
             duplex._final(callback);
           });
           return;
@@ -25830,7 +25830,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          ws.once("open", function open3() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -25897,7 +25897,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash4 } = __require("crypto");
+    var { createHash: createHash5 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -26204,7 +26204,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -27777,9 +27777,9 @@ var A2AServer = class {
 };
 
 // src/index.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname4, resolve as resolve3 } from "node:path";
+import { dirname as dirname5, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/task-context.ts
@@ -28249,7 +28249,7 @@ var ChatStore = class {
   }
   /** Ensure the conv directory exists. Idempotent. */
   async ensureDir(convId) {
-    await mkdir(this.dirFor(convId), { recursive: true });
+    await mkdir(this.dirFor(convId), { recursive: true, mode: 448 });
   }
   /**
    * Write metadata for a conversation. Called on `channel_join` so the agent
@@ -28303,7 +28303,13 @@ var ChatStore = class {
         }
       });
       if (duplicate) return;
-      await appendFile(this.jsonlPath(convId), JSON.stringify(msg) + "\n");
+      const file = await open(this.jsonlPath(convId), "a", 384);
+      try {
+        await file.writeFile((raw && !raw.endsWith("\n") ? "\n" : "") + JSON.stringify(msg) + "\n");
+        await file.sync();
+      } finally {
+        await file.close();
+      }
       appended = true;
     });
     this.#appendQueues.set(convId, current);
@@ -28451,8 +28457,216 @@ function isNotFound(err) {
   return !!err && typeof err === "object" && err.code === "ENOENT";
 }
 
+// src/chat-turns.ts
+import { join as join3 } from "node:path";
+
+// src/private-chat-records.ts
+import { createHash as createHash2, randomUUID as randomUUID5 } from "node:crypto";
+import { mkdir as mkdir2, open as open2, readdir, readFile as readFile2, rename, unlink } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var PrivateChatRecords = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  key(value) {
+    return createHash2("sha256").update(value).digest("hex");
+  }
+  path(key) {
+    if (!/^[a-f0-9]{64}$/.test(key)) throw new Error("CHAT_RECORD_KEY_INVALID");
+    return join2(this.root, `${key}.json`);
+  }
+  async get(key) {
+    try {
+      return JSON.parse(await readFile2(this.path(key), "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw new Error("CHAT_RECORD_READ_FAILED");
+    }
+  }
+  async put(key, value) {
+    await mkdir2(this.root, { recursive: true, mode: 448 });
+    const target = this.path(key);
+    const tmp = `${target}.${randomUUID5()}.tmp`;
+    const file = await open2(tmp, "wx", 384);
+    try {
+      await file.writeFile(JSON.stringify(value));
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    await rename(tmp, target);
+    const dir = await open2(this.root, "r");
+    try {
+      await dir.sync();
+    } finally {
+      await dir.close();
+    }
+  }
+  async remove(key) {
+    await unlink(this.path(key)).catch((error) => {
+      if (error.code !== "ENOENT") throw new Error("CHAT_RECORD_DELETE_FAILED");
+    });
+  }
+  async entries() {
+    const names = await readdir(this.root).catch((error) => {
+      if (error.code === "ENOENT") return [];
+      throw new Error("CHAT_RECORD_LIST_FAILED");
+    });
+    const result = [];
+    for (const name of names.sort()) {
+      if (!/^[a-f0-9]{64}\.json$/.test(name)) continue;
+      const key = name.slice(0, -5);
+      const record = await this.get(key);
+      if (record) result.push([key, record]);
+    }
+    return result;
+  }
+};
+
+// src/chat-turns.ts
+function waitForChatTurn(work, signal) {
+  if (!signal) return work;
+  return new Promise((resolve4, reject) => {
+    const abort = () => reject(new Error("CHAT_WAIT_ABORTED"));
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    work.then(resolve4, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+var ChatTurns = class {
+  constructor(options) {
+    this.options = options;
+    this.records = new PrivateChatRecords(join3(options.root, ".turns", new PrivateChatRecords("").key(options.owner)));
+  }
+  options;
+  records;
+  jobs = /* @__PURE__ */ new Map();
+  tails = /* @__PURE__ */ new Map();
+  active = 0;
+  slots = [];
+  ready;
+  start() {
+    return this.ready ??= this.recover();
+  }
+  async recover() {
+    const entries = await this.records.entries();
+    entries.sort((a, b) => a[1].frame.timestamp.localeCompare(b[1].frame.timestamp));
+    for (const [key, turn] of entries) {
+      if (turn.phase === "running" || turn.phase === "recovering") {
+        turn.phase = turn.runId ? "recovering" : "uncertain";
+        await this.records.put(key, turn);
+      }
+      if (turn.phase === "uncertain") {
+        this.options.progress(turn.frame, "uncertain");
+      } else if (turn.phase !== "completed" || turn.text !== void 0) {
+        this.schedule(key, turn);
+      }
+    }
+  }
+  async submit(frame, signal) {
+    await this.start();
+    const key = this.records.key(`${frame.convId}:${frame.id}`);
+    let job = this.jobs.get(key);
+    if (!job) {
+      job = this.admit(key, frame);
+      this.jobs.set(key, job);
+      void job.finally(() => {
+        if (this.jobs.get(key) === job) this.jobs.delete(key);
+      }).catch(() => {
+      });
+    }
+    return waitForChatTurn(job, signal);
+  }
+  async admit(key, frame) {
+    const existing = await this.records.get(key);
+    if (existing) {
+      if (existing.phase === "completed") return;
+      if (existing.phase === "uncertain") {
+        this.options.progress(frame, "uncertain");
+        return;
+      }
+    }
+    const turn = existing ?? { frame, phase: "accepted" };
+    if (!existing) await this.records.put(key, turn);
+    this.options.progress(frame, turn.phase);
+    await this.queue(key, turn);
+  }
+  schedule(key, turn) {
+    const job = this.queue(key, turn);
+    this.jobs.set(key, job);
+    void job.finally(() => {
+      if (this.jobs.get(key) === job) this.jobs.delete(key);
+    }).catch(() => {
+    });
+  }
+  queue(key, turn) {
+    const previous = this.tails.get(turn.frame.convId) ?? Promise.resolve();
+    const job = previous.catch(() => {
+    }).then(() => this.run(key, turn));
+    this.tails.set(turn.frame.convId, job);
+    void job.finally(() => {
+      if (this.tails.get(turn.frame.convId) === job) this.tails.delete(turn.frame.convId);
+    }).catch(() => {
+    });
+    return job;
+  }
+  async run(key, turn) {
+    if (this.active >= (this.options.concurrency ?? 4)) await new Promise((resolve4) => this.slots.push(resolve4));
+    this.active += 1;
+    const progress = () => this.options.progress(turn.frame, turn.phase);
+    const timer = setInterval(progress, this.options.progressMs ?? 3e4);
+    timer.unref?.();
+    try {
+      if (turn.phase !== "completed") {
+        turn.phase = turn.runId ? "recovering" : "running";
+        await this.records.put(key, turn);
+        progress();
+        const text = await this.options.execute(turn.frame, {
+          runId: turn.runId,
+          saveRunId: async (id) => {
+            turn.runId = id;
+            await this.records.put(key, turn);
+          }
+        });
+        turn.text = text ?? void 0;
+        turn.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        turn.phase = "completed";
+        await this.records.put(key, turn);
+      }
+      if (turn.text !== void 0) await this.options.reply(turn, `chat-${key}`);
+      turn.text = void 0;
+      await this.records.put(key, turn);
+      progress();
+    } catch (error) {
+      if (turn.phase !== "completed") {
+        const code = error instanceof Error ? error.message : "";
+        if (["CHAT_RUNTIME_RUN_FAILED", "CHAT_RUNTIME_EMPTY_FINAL", "CHAT_RUNTIME_HTTP_404", "CHAT_RUNTIME_INVALID_STATUS"].includes(code)) {
+          turn.runId = void 0;
+        }
+        turn.phase = turn.runId ? "recovering" : "uncertain";
+        await this.records.put(key, turn).catch(() => {
+        });
+      }
+      progress();
+      this.options.error("CHAT_TURN_PENDING_RECONCILIATION");
+      if (turn.phase === "completed" || turn.runId) {
+        const retry = setTimeout(() => this.schedule(key, turn), 15e3);
+        retry.unref?.();
+      }
+    } finally {
+      clearInterval(timer);
+      this.active -= 1;
+      this.slots.shift()?.();
+    }
+  }
+};
+
 // src/openclaw-supervisor-client.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { spawn } from "node:child_process";
 import { closeSync, existsSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, realpathSync, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
@@ -28461,30 +28675,30 @@ import { dirname as dirname2, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/supervisor-protocol.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { dirname, join as join4 } from "node:path";
 var SUPERVISOR_PROTOCOL_VERSION = 2;
 var SUPERVISOR_RENEW_MS = 5e3;
 var CURRENT_PROCESS_EPOCH_MS = Math.floor(Date.now() - process.uptime() * 1e3);
 function supervisorOwnerHash(lifecycleKey) {
-  return createHash2("sha256").update(lifecycleKey).digest("hex");
+  return createHash3("sha256").update(lifecycleKey).digest("hex");
 }
 function supervisorDir(stateDir) {
-  return join2(stateDir, "perkos-a2a", "supervisors");
+  return join4(stateDir, "perkos-a2a", "supervisors");
 }
 function supervisorSocketPath(stateDir, ownerHash) {
-  const preferred = join2(supervisorDir(stateDir), `${ownerHash.slice(0, 32)}.sock`);
+  const preferred = join4(supervisorDir(stateDir), `${ownerHash.slice(0, 32)}.sock`);
   if (Buffer.byteLength(preferred) <= 96) return preferred;
   const uid = typeof process.getuid === "function" ? process.getuid() : "user";
-  return join2(tmpdir(), `perkos-a2a-${uid}`, `${ownerHash.slice(0, 32)}.sock`);
+  return join4(tmpdir(), `perkos-a2a-${uid}`, `${ownerHash.slice(0, 32)}.sock`);
 }
 function supervisorBootstrapPath(stateDir, ownerHash) {
-  return join2(supervisorDir(stateDir), `${ownerHash}.bootstrap.json`);
+  return join4(supervisorDir(stateDir), `${ownerHash}.bootstrap.json`);
 }
 function supervisorRolloverLockPath(stateDir, ownerHash) {
-  return join2(supervisorDir(stateDir), `${ownerHash}.rollover.lock`);
+  return join4(supervisorDir(stateDir), `${ownerHash}.rollover.lock`);
 }
 function currentBootId() {
   try {
@@ -28601,7 +28815,7 @@ var OpenClawSupervisorClient = class {
     return this.requestWithMessage({
       protocolVersion: 2,
       type: "claim",
-      requestId: randomUUID5(),
+      requestId: randomUUID6(),
       lease: this.freshLease(),
       config: this.config
     }, 15e3);
@@ -28626,7 +28840,7 @@ var OpenClawSupervisorClient = class {
         const stopped = await this.requestWithMessage({
           protocolVersion: 2,
           type: "release",
-          requestId: randomUUID5(),
+          requestId: randomUUID6(),
           lease: this.freshLease()
         }, 8e3);
         if (stopped?.state !== "STOPPED") throw new Error("OWNER_STOP_TIMEOUT:legacy supervisor did not return STOPPED");
@@ -28635,7 +28849,7 @@ var OpenClawSupervisorClient = class {
         const stopped = await this.requestWithMessage({
           protocolVersion: 2,
           type: "prepareRollover",
-          requestId: randomUUID5(),
+          requestId: randomUUID6(),
           lease: this.freshLease(),
           targetVersion: this.config.version,
           targetInstallRoot: this.config.installRoot
@@ -28747,7 +28961,7 @@ var OpenClawSupervisorClient = class {
     this.renewTimer = null;
     const stopping = (async () => {
       if (this.socket && !this.socket.destroyed) {
-        const requestId = randomUUID5();
+        const requestId = randomUUID6();
         try {
           await this.requestWithMessage({
             protocolVersion: 2,
@@ -28779,13 +28993,16 @@ var OpenClawSupervisorClient = class {
     return await this.request("discover", {}, 15e3);
   }
   sendTaskResponse(original, result) {
-    this.write({ protocolVersion: 2, type: "relayTaskResult", lease: this.freshLease(), eventId: randomUUID5(), original, result });
+    this.write({ protocolVersion: 2, type: "relayTaskResult", lease: this.freshLease(), eventId: randomUUID6(), original, result });
   }
   async sendChatReply(payload) {
     return await this.request("chatReply", payload, 15e3);
   }
+  async sendChatProgress(payload) {
+    await this.request("chatProgress", payload, 5e3);
+  }
   async request(method, payload, timeoutMs) {
-    const requestId = randomUUID5();
+    const requestId = randomUUID6();
     return this.requestWithMessage({ protocolVersion: 2, type: "request", requestId, lease: this.freshLease(), method, payload }, timeoutMs);
   }
   async requestWithMessage(message, timeoutMs) {
@@ -28970,7 +29187,7 @@ var OpenClawSupervisorClient = class {
 };
 
 // src/runtime-evidence.ts
-import { createHash as createHash3, createHmac, timingSafeEqual } from "node:crypto";
+import { createHash as createHash4, createHmac, timingSafeEqual } from "node:crypto";
 import {
   chmodSync as chmodSync2,
   mkdirSync as mkdirSync3,
@@ -28979,7 +29196,7 @@ import {
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join3, resolve as resolve2 } from "node:path";
+import { join as join5, resolve as resolve2 } from "node:path";
 var RUNTIME_ATTEMPT_SCHEMA_VERSION = 2;
 var RUNTIME_STATUS_SCHEMA_VERSION = 3;
 function canonicalize(value) {
@@ -29034,20 +29251,20 @@ function canonicalConfigJson(config) {
   return JSON.stringify({ schemaVersion: RUNTIME_STATUS_SCHEMA_VERSION, config: canonicalize(configEvidenceProjection(config)) });
 }
 function configDigest(config) {
-  return createHash3("sha256").update(canonicalConfigJson(config)).digest("hex");
+  return createHash4("sha256").update(canonicalConfigJson(config)).digest("hex");
 }
 function configFingerprint(config, hmacKeyHex) {
   if (!/^[a-f0-9]{64}$/u.test(hmacKeyHex)) throw new Error("runtime evidence HMAC key is invalid");
   return createHmac("sha256", Buffer.from(hmacKeyHex, "hex")).update(canonicalConfigJson(config)).digest("hex");
 }
 function runtimeEvidenceDir(stateDir) {
-  return resolve2(stateDir ?? process.env.OPENCLAW_STATE_DIR ?? join3(homedir4(), ".openclaw"), "perkos-a2a");
+  return resolve2(stateDir ?? process.env.OPENCLAW_STATE_DIR ?? join5(homedir4(), ".openclaw"), "perkos-a2a");
 }
 function runtimeAttemptPath(stateDir) {
-  return join3(runtimeEvidenceDir(stateDir), "active-attempt.json");
+  return join5(runtimeEvidenceDir(stateDir), "active-attempt.json");
 }
 function runtimeStatusPath(stateDir) {
-  return join3(runtimeEvidenceDir(stateDir), "runtime-status.json");
+  return join5(runtimeEvidenceDir(stateDir), "runtime-status.json");
 }
 function configAgentId(config) {
   if (config.platform?.agentId) return config.platform.agentId;
@@ -29239,10 +29456,186 @@ function formatProjectContext(context) {
   return lines;
 }
 
+// src/chat-runtime-http.ts
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+function chatRuntimeJson(url, init) {
+  return new Promise((resolve4, reject) => {
+    const fail = () => reject(new Error("CHAT_RUNTIME_TRANSPORT_UNCERTAIN"));
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      fail();
+      return;
+    }
+    const req = (parsed.protocol === "https:" ? httpsRequest : httpRequest)(parsed, {
+      method: init.method,
+      headers: init.headers
+    }, (res) => {
+      if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+        res.resume();
+        reject(new Error(`CHAT_RUNTIME_HTTP_${res.statusCode ?? 0}`));
+        return;
+      }
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > 16 * 1024 * 1024) {
+          res.destroy();
+          fail();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on("error", fail);
+      res.on("aborted", fail);
+      res.on("end", () => {
+        try {
+          resolve4(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+        } catch {
+          reject(new Error("CHAT_RUNTIME_INVALID_RESPONSE"));
+        }
+      });
+    });
+    req.on("error", fail);
+    const connectTimer = setTimeout(() => req.destroy(new Error("CHAT_RUNTIME_CONNECT_TIMEOUT")), 15e3);
+    connectTimer.unref?.();
+    req.on("socket", (socket) => {
+      if (!socket.connecting) clearTimeout(connectTimer);
+      else socket.once(parsed.protocol === "https:" ? "secureConnect" : "connect", () => clearTimeout(connectTimer));
+    });
+    req.on("close", () => clearTimeout(connectTimer));
+    req.end(init.body);
+  });
+}
+async function runChatRuntime(url, headers, body, checkpoint, request = chatRuntimeJson, pollMs = 2e3) {
+  const isRuns = new URL(url).pathname.replace(/\/$/, "").endsWith("/v1/runs");
+  if (!isRuns) {
+    if (checkpoint.runId) throw new Error("CHAT_RUNTIME_RECOVERY_ENDPOINT_CHANGED");
+    return request(url, { method: "POST", headers, body });
+  }
+  let runId = checkpoint.runId;
+  if (!runId) {
+    const started = await request(url, { method: "POST", headers, body });
+    if (typeof started?.run_id !== "string" || !started.run_id) throw new Error("CHAT_RUNTIME_RUN_ID_MISSING");
+    runId = started.run_id;
+    await checkpoint.saveRunId(runId);
+  }
+  for (; ; ) {
+    const result = await request(`${url.replace(/\/$/, "")}/${encodeURIComponent(runId)}`, { method: "GET", headers });
+    if (result?.status === "completed") {
+      if (typeof result.output !== "string" || !result.output.trim()) throw new Error("CHAT_RUNTIME_EMPTY_FINAL");
+      return { output: [{ role: "assistant", content: [{ type: "output_text", text: result.output }] }] };
+    }
+    if (result?.status === "failed" || result?.status === "cancelled") throw new Error("CHAT_RUNTIME_RUN_FAILED");
+    if (!["started", "running", "queued", "pending", "awaiting_approval"].includes(result?.status ?? "")) throw new Error("CHAT_RUNTIME_INVALID_STATUS");
+    await new Promise((resolve4) => setTimeout(resolve4, pollMs));
+  }
+}
+
 // src/bridge-chat-reply.ts
+function hermesDeliveryUrl(baseUrl, endpoint, profile) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const prefix = profile ? `/p/${encodeURIComponent(profile)}` : "";
+  const ep = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+  return `${base}${prefix}${ep}`;
+}
+function personaInstructions() {
+  const b64 = process.env.PERKOS_AGENT_SOUL_B64 || "";
+  if (!b64.trim()) return "";
+  try {
+    return Buffer.from(b64, "base64").toString("utf8").trim();
+  } catch {
+    return "";
+  }
+}
 function usesHttpDelivery(runtimeKind) {
   return runtimeKind === "hermes" || runtimeKind === "hermes-api" || runtimeKind === "zeroclaw" || runtimeKind === "custom";
 }
+async function deliverToHermes(config, message, wantResponse = false, sessionKeyOverride, chatCheckpoint) {
+  const runtime2 = config.runtime || {};
+  const baseUrl = (runtime2.hermesUrl || process.env.HERMES_API_URL || process.env.HERMES_WORKSPACE_URL || "http://127.0.0.1:8642").replace(/\/+$/, "");
+  const endpoint = runtime2.hermesEndpoint || process.env.HERMES_API_ENDPOINT || process.env.HERMES_WORKSPACE_ENDPOINT || "/v1/responses";
+  const sessionKey = sessionKeyOverride || runtime2.sessionKey || process.env.HERMES_SESSION_ID || process.env.HERMES_SESSION_KEY || "a2a";
+  const token = runtime2.hermesToken || process.env.API_SERVER_KEY || process.env.HERMES_API_KEY || process.env.HERMES_WORKSPACE_TOKEN || process.env.HERMES_SESSION_TOKEN;
+  const profile = runtime2.hermesProfile || process.env.PERKOS_HERMES_PROFILE || "";
+  const url = hermesDeliveryUrl(baseUrl, endpoint, profile);
+  const headers = {
+    "content-type": "application/json",
+    "x-hermes-session-id": sessionKey,
+    "x-hermes-session-key": sessionKey
+  };
+  if (token) headers.authorization = `Bearer ${token}`;
+  const normalizedEndpoint = endpoint.replace(/^\/?/, "/");
+  const persona = personaInstructions();
+  const model = runtime2.model?.trim() || process.env.HERMES_MODEL?.trim();
+  const body = normalizedEndpoint.startsWith("/webhook") ? { message } : normalizedEndpoint.startsWith("/v1/chat/completions") ? {
+    ...model ? { model } : {},
+    messages: [
+      ...persona ? [{ role: "system", content: persona }] : [],
+      { role: "user", content: message }
+    ],
+    stream: false
+  } : normalizedEndpoint.startsWith("/v1/runs") ? { input: message, session_id: sessionKey, ...persona ? { instructions: persona } : {} } : normalizedEndpoint.startsWith("/v1/responses") ? { ...model ? { model } : {}, input: message, store: true, ...persona ? { instructions: persona } : {} } : { sessionKey, message };
+  if (chatCheckpoint) return runChatRuntime(url, headers, JSON.stringify(body), chatCheckpoint);
+  const timeoutMs = Math.max(
+    1e3,
+    Number(process.env.PERKOS_RUNTIME_DELIVERY_TIMEOUT_MS) || 24e4
+  );
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`Hermes API delivery failed (${response.status})`);
+  }
+  if (!wantResponse) return void 0;
+  return await response.json();
+}
+function chatSessionKey(convId) {
+  const safe2 = convId.replace(/[^a-zA-Z0-9_.:-]/g, "-").slice(0, 160);
+  return `perkos-chat:${safe2 || "unknown"}`;
+}
+function autoReplyEnabled() {
+  return String(process.env.A2A_HERMES_AUTO_REPLY || "").toLowerCase() === "true";
+}
+function extractAssistantText(resp) {
+  if (!resp || typeof resp !== "object") return null;
+  const r = resp;
+  const output = r.output;
+  if (Array.isArray(output)) {
+    for (const item of [...output].reverse()) {
+      if (!item || typeof item !== "object") continue;
+      if (item.role && item.role !== "assistant") continue;
+      if (item.type && item.type !== "message") continue;
+      if (item.status && item.status !== "completed") continue;
+      const content = item.content;
+      if (!Array.isArray(content)) continue;
+      const text = [];
+      for (const part of content) {
+        if (!part || typeof part !== "object") continue;
+        const p = part;
+        if ((!p.type || p.type === "output_text" || p.type === "text") && typeof p.text === "string" && p.text.trim()) text.push(p.text);
+      }
+      if (text.length) return text.join("\n");
+    }
+  }
+  if (typeof r.response === "string" && r.response.trim()) return r.response;
+  const choices = r.choices;
+  if (Array.isArray(choices)) {
+    for (const choice of choices) {
+      if (!choice || typeof choice !== "object") continue;
+      const message = choice.message;
+      if (!message || typeof message !== "object") continue;
+      const content = message.content;
+      if (typeof content === "string" && content.trim()) return content;
+    }
+  }
+  return null;
+}
 
 // src/platform-control-plane.ts
 function resolvePlatformControlPlane(config, env = process.env) {
@@ -29310,12 +29703,67 @@ async function tryHandleInstalledVoiceMarker(message, config, loadVoice = defaul
 
 // src/a2a-maintenance.ts
 import { spawn as spawn2 } from "node:child_process";
-import { chmod, mkdir as mkdir2, readdir, readFile as readFile2, rename, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile3, unlink as unlink2 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var PERKOS_A2A_UPDATE_PREFIX = "PERKOS_A2A_UPDATE:";
+
+// src/service-environment.ts
+import { delimiter, dirname as dirname3, isAbsolute } from "node:path";
+function serviceEnvironment(nodePath = process.execPath, inherited = process.env) {
+  const paths = [
+    dirname3(nodePath),
+    ...(inherited.PATH ?? "").split(delimiter),
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ];
+  return { ...inherited, PATH: [...new Set(paths.filter(isAbsolute))].join(delimiter) };
+}
+
+// src/maintenance-result.ts
+import { chmod, mkdir as mkdir3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+var MAINTENANCE_ERRORS = [
+  "npx_unavailable",
+  "npx_exec_failed",
+  "invalid_update_receipt",
+  "update_failed",
+  "managed_install_not_found",
+  "managed_config_invalid",
+  "managed_identity_mismatch",
+  "bridge_install_missing",
+  "bridge_version_mismatch"
+];
+var TARGET_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 var REQUEST_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function safeMaintenanceError(value) {
+  return typeof value === "string" && MAINTENANCE_ERRORS.includes(value) ? value : "update_failed";
+}
+function parseMaintenanceResult(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  if (v.state === "completed" && typeof v.installedVersion === "string" && TARGET_VERSION.test(v.installedVersion)) {
+    return { schemaVersion: 2, state: "completed", installedVersion: v.installedVersion };
+  }
+  if (v.state === "failed") return { schemaVersion: 2, state: "failed", errorCode: safeMaintenanceError(v.errorCode) };
+  return null;
+}
+function maintenanceReportBody(result) {
+  return result.state === "completed" ? { state: result.state, installedVersion: result.installedVersion } : { state: result.state, errorCode: result.errorCode };
+}
+async function atomicPrivateJson(path, value) {
+  await mkdir3(dirname4(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify(value)}
+`, { mode: 384 });
+  await chmod(temporary, 384);
+  await rename2(temporary, path);
+}
+
+// src/a2a-maintenance.ts
+var PERKOS_A2A_UPDATE_PREFIX = "PERKOS_A2A_UPDATE:";
 var BRIDGE_INSTANCE_ID = REQUEST_ID;
 function parseA2AUpdateMarker(message) {
   const marker = message.trim();
@@ -29325,15 +29773,7 @@ function parseA2AUpdateMarker(message) {
 }
 var maintenanceControlPlane = resolvePlatformControlPlane;
 function maintenanceRoot(agentId) {
-  return join4(homedir5(), ".perkos", "a2a", "hermes", agentId, "maintenance");
-}
-async function atomicPrivateJson(path, value) {
-  await mkdir2(dirname3(path), { recursive: true, mode: 448 });
-  const temporary = `${path}.${process.pid}.tmp`;
-  await writeFile2(temporary, `${JSON.stringify(value)}
-`, { mode: 384 });
-  await chmod(temporary, 384);
-  await rename(temporary, path);
+  return join6(homedir5(), ".perkos", "a2a", "hermes", agentId, "maintenance");
 }
 async function authorizedJson(url, relayApiKey, init = {}) {
   const response = await fetch(url, {
@@ -29363,12 +29803,20 @@ async function claimRequest(target, requestId, bridgeInstanceId) {
 }
 async function queueHermesMaintenanceJob(job) {
   const root = maintenanceRoot(job.agentId);
-  const jobPath = join4(root, "jobs", `${job.requestId}.json`);
+  const jobPath = join6(root, "jobs", `${job.requestId}.json`);
   await atomicPrivateJson(jobPath, job);
   const runnerPath = fileURLToPath2(new URL("./maintenance-runner.js", import.meta.url));
   const child = spawn2(process.execPath, [runnerPath, "--job", jobPath], {
     detached: true,
-    stdio: "ignore"
+    stdio: "ignore",
+    env: serviceEnvironment()
+  });
+  await new Promise((resolve4, reject) => {
+    child.once("spawn", resolve4);
+    child.once("error", () => reject(new Error("runner_spawn_failed")));
+  }).catch(async () => {
+    await unlink2(jobPath).catch(() => void 0);
+    throw new Error("runner_spawn_failed");
   });
   child.unref();
 }
@@ -29399,40 +29847,118 @@ async function tryHandleA2AMaintenanceMarker(message, config, deps = {}) {
     return "PERKOS_A2A_UPDATE_FAILED:request_rejected";
   }
 }
-async function reportReceipt(receipt, target) {
+async function reportReceipt(requestId, receipt, target) {
   await authorizedJson(
-    `${target.apiBaseUrl}/agents/${encodeURIComponent(target.agentId)}/maintenance/a2a-update/${receipt.requestId}/report`,
+    `${target.apiBaseUrl}/agents/${encodeURIComponent(target.agentId)}/maintenance/a2a-update/${requestId}/report`,
     target.relayApiKey,
     {
       method: "POST",
-      body: JSON.stringify({
-        state: receipt.state,
-        ...receipt.installedVersion ? { installedVersion: receipt.installedVersion } : {},
-        ...receipt.errorCode ? { errorCode: receipt.errorCode } : {}
-      })
+      body: JSON.stringify(maintenanceReportBody(receipt))
     }
   );
 }
-async function flushMaintenanceReceipts(config) {
+async function flushMaintenanceReceipts(config, root) {
   const target = maintenanceControlPlane(config);
   if (!target) return;
-  const receiptsDir = join4(maintenanceRoot(target.agentId), "receipts");
-  const files = await readdir(receiptsDir).catch(() => []);
+  const privateRoot = root ?? maintenanceRoot(target.agentId);
+  const receiptsDir = join6(privateRoot, "receipts");
+  const files = await readdir2(receiptsDir).catch(() => []);
   for (const file of files) {
-    if (!file.endsWith(".json")) continue;
-    const path = join4(receiptsDir, file);
+    if (!file.endsWith(".json") || !REQUEST_ID.test(file.slice(0, -5))) continue;
+    const path = join6(receiptsDir, file);
     try {
-      const receipt = JSON.parse(await readFile2(path, "utf8"));
-      if (receipt.agentId !== target.agentId || receipt.apiBaseUrl !== target.apiBaseUrl || !REQUEST_ID.test(receipt.requestId)) continue;
-      await reportReceipt(receipt, target);
-      await unlink(path);
+      const stored = JSON.parse(await readFile3(path, "utf8"));
+      const routingPath = join6(privateRoot, "pending-reports", file);
+      const routing = stored.schemaVersion === 1 ? stored : stored.schemaVersion === 2 ? JSON.parse(await readFile3(routingPath, "utf8")) : null;
+      if (!routing || routing.agentId !== target.agentId || routing.apiBaseUrl !== target.apiBaseUrl || routing.requestId !== file.slice(0, -5)) continue;
+      const receipt = parseMaintenanceResult(stored);
+      if (!receipt) continue;
+      if (stored.schemaVersion === 1) {
+        await atomicPrivateJson(routingPath, {
+          schemaVersion: 1,
+          requestId: routing.requestId,
+          agentId: routing.agentId,
+          apiBaseUrl: routing.apiBaseUrl
+        });
+        await atomicPrivateJson(path, receipt);
+      }
+      await reportReceipt(file.slice(0, -5), receipt, target);
+      await unlink2(path);
+      await unlink2(routingPath).catch(() => void 0);
     } catch {
     }
   }
 }
 
 // src/chat-client.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
+
+// src/chat-outbox.ts
+import { join as join7 } from "node:path";
+var ChatOutbox = class {
+  constructor(store, owner) {
+    this.store = store;
+    this.records = new PrivateChatRecords(join7(store.root, ".outbox", new PrivateChatRecords("").key(owner)));
+  }
+  store;
+  records;
+  pending = /* @__PURE__ */ new Map();
+  nextAttempt = /* @__PURE__ */ new Map();
+  attempts = /* @__PURE__ */ new Map();
+  serial = Promise.resolve();
+  loaded = false;
+  lock(fn) {
+    const work = this.serial.catch(() => {
+    }).then(fn);
+    this.serial = work;
+    return work;
+  }
+  async load() {
+    if (this.loaded) return;
+    for (const [key, value] of await this.records.entries()) this.pending.set(key, value);
+    this.loaded = true;
+  }
+  enqueue(entry) {
+    return this.lock(async () => {
+      await this.load();
+      const key = this.records.key(`${entry.frame.convId}:${entry.frame.id}`);
+      const existing = this.pending.get(key);
+      if (existing) return;
+      await this.records.put(key, entry);
+      this.pending.set(key, entry);
+      await this.store.appendIdempotent(entry.frame.convId, entry.message);
+    });
+  }
+  flush(send, force = false) {
+    return this.lock(async () => {
+      await this.load();
+      const sent = /* @__PURE__ */ new Set();
+      for (const [key, entry] of this.pending) {
+        if (!force && Date.now() < (this.nextAttempt.get(key) ?? 0)) continue;
+        await this.store.appendIdempotent(entry.frame.convId, entry.message);
+        if (!send(entry.frame)) break;
+        sent.add(entry.frame.id);
+        const attempt = (this.attempts.get(key) ?? 0) + 1;
+        this.attempts.set(key, attempt);
+        this.nextAttempt.set(key, Date.now() + Math.min(6e4, 5e3 * 2 ** Math.min(attempt - 1, 4)));
+      }
+      return sent;
+    });
+  }
+  acknowledge(convId, id) {
+    return this.lock(async () => {
+      await this.load();
+      const key = this.records.key(`${convId}:${id}`);
+      if (!this.pending.has(key)) return;
+      await this.records.remove(key);
+      this.pending.delete(key);
+      this.attempts.delete(key);
+      this.nextAttempt.delete(key);
+    });
+  }
+};
+
+// src/chat-client.ts
 var DEFAULT_URL = "wss://chat.perkos.xyz/chat";
 var DEFAULT_HISTORY_LIMIT = 50;
 var DEFAULT_MIN_RECONNECT = 1e3;
@@ -29449,6 +29975,9 @@ var ChatClient = class {
   handlers;
   logger;
   store;
+  outbox;
+  outboxTimer = null;
+  progress = /* @__PURE__ */ new Map();
   reconnectMs;
   reconnectTimer = null;
   heartbeatTimer = null;
@@ -29477,6 +30006,7 @@ var ChatClient = class {
     this.handlers = opts.handlers ?? {};
     this.logger = this.handlers.logger ?? { info: console.log, error: console.error };
     this.store = new ChatStore({ storeRoot: this.config.storeRoot });
+    this.outbox = new ChatOutbox(this.store, this.agentName);
     this.reconnectMs = this.config.minReconnectMs;
   }
   /** Storage handle — exposed so consumers can read history without going through the wire. */
@@ -29536,32 +30066,50 @@ var ChatClient = class {
   }
   /**
    * Send a reply from this agent into a conversation. Appends to the local
-   * store optimistically, then sends to the server. If the WS is offline,
-   * the local store is still updated and the message is dropped from the
-   * wire — callers should re-send after reconnect if guaranteed delivery is
-   * required (the simple agent loop should just regenerate from history).
+   * outbox and canonical history before sending. Offline replies are replayed
+   * after authentication, with stable IDs, until acknowledged by the router.
+   * `delivered` only means transmission attempted, not human receipt.
    */
   async sendReply(opts) {
-    const id = randomUUID6();
+    const id = opts.id ?? randomUUID7();
     const msg = {
       id,
       from: `agent:${this.agentName}`,
       text: opts.text,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      timestamp: opts.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
       replyTo: opts.replyTo ?? null
     };
-    await this.store.append(opts.convId, msg);
     const frame = {
       type: "chat_reply",
       id,
       convId: opts.convId,
       walletAddress: opts.walletAddress,
       text: opts.text,
-      replyTo: opts.replyTo ?? null
+      replyTo: opts.replyTo ?? null,
+      timestamp: msg.timestamp
     };
-    const delivered = this.sendFrame(frame);
+    await this.outbox.enqueue({ frame, message: msg });
+    const sent = await this.outbox.flush((pending) => this.authed && this.sendFrame(pending));
+    const delivered = sent.has(id);
     return { id, delivered };
   }
+  sendProgress(convId, walletAddress, replyTo, phase) {
+    const key = `${convId}:${replyTo}`;
+    const frame = {
+      type: "typing",
+      convId,
+      walletAddress,
+      replyTo,
+      phase,
+      state: phase === "completed" || phase === "uncertain" ? "stop" : "start"
+    };
+    if (phase === "completed") this.progress.delete(key);
+    else this.progress.set(key, frame);
+    if (this.authed) this.sendFrame(frame);
+  }
+  flushOutbox(force = false) {
+    void this.outbox.flush((frame) => this.authed && this.sendFrame(frame), force).catch(() => this.logger.error("[perkos-chat] CHAT_OUTBOX_RETRY_PENDING"));
+  }
   // -------------------------------------------------------------------------
   // WebSocket lifecycle
   // -------------------------------------------------------------------------
@@ -29613,7 +30161,7 @@ var ChatClient = class {
         clearTimeout(authTimer);
         authTimer = null;
       }
-      void this.handleFrame(frame);
+      void this.handleFrame(frame).catch(() => this.logger.error("[perkos-chat] CHAT_FRAME_PROCESSING_FAILED"));
     });
     this.ws.on("close", (code, reason) => {
       if (authTimer) {
@@ -29640,6 +30188,11 @@ var ChatClient = class {
         this.setAuthed(true);
         this.logger.info(`[perkos-chat] authed as agent:${this.agentName}`);
         this.startHeartbeat();
+        this.flushOutbox(true);
+        for (const progress of this.progress.values()) this.sendFrame(progress);
+        if (this.outboxTimer) clearInterval(this.outboxTimer);
+        this.outboxTimer = setInterval(() => this.flushOutbox(), 5e3);
+        this.outboxTimer.unref?.();
         return;
       case "auth_error":
         this.logger.error(`[perkos-chat] auth_error ${frame.code}: ${frame.message}`);
@@ -29674,6 +30227,8 @@ var ChatClient = class {
         await this.handleChannelJoin(frame);
         return;
       case "ack":
+        await this.outbox.acknowledge(frame.convId, frame.id);
+        return;
       case "pong":
       case "typing":
         return;
@@ -29724,8 +30279,8 @@ var ChatClient = class {
     };
     try {
       await this.store.appendIdempotent(frame.convId, msg);
-    } catch (err) {
-      this.logger.error(`[perkos-chat] failed to append to store: ${errMsg(err)}`);
+    } catch {
+      throw new Error("CHAT_INBOUND_PERSISTENCE_FAILED");
     }
   }
   async handleChannelJoin(frame) {
@@ -29804,11 +30359,18 @@ var ChatClient = class {
       messages: page.messages,
       hasMore: page.hasMore
     });
+    for (const progress of this.progress.values()) {
+      if (progress.convId === frame.convId) this.sendFrame(progress);
+    }
   }
   sendFrame(frame) {
     if (this.ws && this.ws.readyState === wrapper_default.OPEN) {
-      this.ws.send(JSON.stringify(frame));
-      return true;
+      try {
+        this.ws.send(JSON.stringify(frame));
+        return true;
+      } catch {
+        return false;
+      }
     }
     return false;
   }
@@ -29828,6 +30390,10 @@ var ChatClient = class {
     this.reconnectMs = Math.min(delay * 2, this.config.maxReconnectMs);
   }
   clearTimers() {
+    if (this.outboxTimer) {
+      clearInterval(this.outboxTimer);
+      this.outboxTimer = null;
+    }
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
@@ -29903,7 +30469,7 @@ async function mutateOpenClawChatSession(api, config, sessionKey, update) {
   if (typeof patchSessionEntry === "function") {
     await patchSessionEntry({
       sessionKey,
-      fallbackEntry: { sessionId: randomUUID7(), updatedAt: Date.now() },
+      fallbackEntry: { sessionId: randomUUID8(), updatedAt: Date.now() },
       preserveActivity: true,
       replaceEntry: true,
       update
@@ -29920,7 +30486,7 @@ async function mutateOpenClawChatSession(api, config, sessionKey, update) {
   await updateSessionStore(
     storePath,
     (store) => {
-      const current = store[sessionKey] ?? { sessionId: randomUUID7(), updatedAt: Date.now() };
+      const current = store[sessionKey] ?? { sessionId: randomUUID8(), updatedAt: Date.now() };
       store[sessionKey] = update(current);
       return store[sessionKey];
     },
@@ -30132,12 +30698,9 @@ async function runOpenClawChatTurn(api, config, sessionKey, prompt, transcriptPr
   const workspaceDir = resolveAgentWorkspaceDir(runtimeConfig, agentId);
   const sessionContext = readOpenClawChatSession(api, agentId, sessionKey);
   const entry = sessionContext.entry;
-  const sessionId = typeof entry?.sessionId === "string" && entry.sessionId.trim() ? entry.sessionId : randomUUID7();
+  const sessionId = typeof entry?.sessionId === "string" && entry.sessionId.trim() ? entry.sessionId : randomUUID8();
   const configuredTimeout = api.runtime?.agent?.resolveAgentTimeoutMs?.(runtimeConfig);
-  const timeoutMs = Math.min(
-    75e3,
-    typeof configuredTimeout === "number" && configuredTimeout > 0 ? configuredTimeout : 75e3
-  );
+  const timeoutMs = typeof configuredTimeout === "number" && Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : 30 * 6e4;
   let selectedProvider = runtimeRoute?.provider;
   let selectedModel = runtimeRoute?.model;
   if (runtimeRoute) {
@@ -30155,7 +30718,7 @@ async function runOpenClawChatTurn(api, config, sessionKey, prompt, transcriptPr
     prompt,
     transcriptPrompt,
     timeoutMs,
-    runId: randomUUID7(),
+    runId: randomUUID8(),
     trigger: "user",
     messageChannel: "perkos-chat",
     disableTools: true,
@@ -30198,16 +30761,13 @@ async function runOpenClawChatTurn(api, config, sessionKey, prompt, transcriptPr
     }
     const reply = extractOpenClawChatReply(result);
     if (!reply) {
-      logger.error(`[perkos-chat] embedded OpenClaw run completed without reply text for ${sessionKey}`);
-      return null;
+      throw new Error("CHAT_RUNTIME_EMPTY_FINAL");
     }
-    logger.info(`[perkos-chat] embedded OpenClaw run completed for ${sessionKey}`);
+    logger.info("[perkos-chat] embedded OpenClaw run completed");
     return reply;
   } catch (err) {
-    logger.error(
-      `[perkos-chat] embedded OpenClaw run failed for ${sessionKey}: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return null;
+    logger.error("[perkos-chat] CHAT_RUNTIME_RESULT_UNCERTAIN");
+    throw new Error("CHAT_RUNTIME_RESULT_UNCERTAIN");
   }
 }
 function parseWalletFromIdentity(identity) {
@@ -30228,7 +30788,7 @@ function formatRecentChatContext(messages, currentMessageId) {
   const transcript = prior.join("\n");
   return transcript.length <= CHAT_CONTEXT_CHAR_LIMIT ? transcript : `\u2026${transcript.slice(-CHAT_CONTEXT_CHAR_LIMIT)}`;
 }
-async function deliverToHermes(config, message, logger) {
+async function deliverToHermes2(config, message, logger) {
   const runtime2 = config.runtime || {};
   const baseUrl = (runtime2.hermesUrl || "http://127.0.0.1:8642").replace(/\/+$/, "");
   const endpoint = runtime2.hermesEndpoint || "/v1/responses";
@@ -30294,10 +30854,10 @@ function register(api) {
   );
   const logger = api.logger || console;
   const pluginVersion = loadedPluginVersion();
-  const pluginRoot = resolve3(dirname4(fileURLToPath3(import.meta.url)), "..");
+  const pluginRoot = resolve3(dirname5(fileURLToPath3(import.meta.url)), "..");
   const server = new A2AServer(pluginConfig, logger, { relayOwnership: "external-required" });
   const lifecycleKey = a2aLifecycleKey(pluginConfig);
-  const lifecycleInstanceId = randomUUID7();
+  const lifecycleInstanceId = randomUUID8();
   const pendingTasks = [];
   const enqueueSystemEvent = api.runtime?.system?.enqueueSystemEvent;
   const requestHeartbeatNow = api.runtime?.system?.requestHeartbeatNow;
@@ -30349,10 +30909,10 @@ function register(api) {
     });
     if (handledAgentically) return;
     if (usesHttpDelivery(runtimeKind)) {
-      await deliverToHermes(pluginConfig, eventText, logger);
+      await deliverToHermes2(pluginConfig, eventText, logger);
       task.artifacts.push({
         kind: "artifact",
-        artifactId: randomUUID7(),
+        artifactId: randomUUID8(),
         parts: [{ kind: "text", text: `debug: delivered task ${task.id} to Hermes API Server` }]
       });
       const finalText2 = await generateRuntimeReply(pluginConfig, text, marker);
@@ -30362,7 +30922,7 @@ function register(api) {
     if (runtimeKind === "none") {
       task.artifacts.push({
         kind: "artifact",
-        artifactId: randomUUID7(),
+        artifactId: randomUUID8(),
         parts: [{ kind: "text", text: `debug: runtime delivery disabled for ${marker}` }]
       });
       return;
@@ -30375,7 +30935,7 @@ function register(api) {
     }
     task.artifacts.push({
       kind: "artifact",
-      artifactId: randomUUID7(),
+      artifactId: randomUUID8(),
       parts: [{ kind: "text", text: `debug: enqueued system event for ${marker}` }]
     });
     if (enqueueSystemEvent) {
@@ -30459,7 +31019,7 @@ function register(api) {
       if (!finalText) continue;
       task.artifacts.push({
         kind: "artifact",
-        artifactId: randomUUID7(),
+        artifactId: randomUUID8(),
         parts: [{ kind: "text", text: finalText }]
       });
       task.status = {
@@ -30477,21 +31037,15 @@ function register(api) {
   const chatEnabled = Boolean(pluginConfig.chat?.enabled && chatApiKey);
   const chatStore = chatEnabled ? new ChatStore({ storeRoot: pluginConfig.chat?.storeRoot }) : null;
   let supervisorClient;
-  const handleSupervisorChatDeliver = async (frame) => {
+  const executeSupervisorChat = async (frame, checkpoint) => {
     const walletAddress = parseWalletFromIdentity(frame.from);
-    const maintenanceReply = await tryHandleA2AMaintenanceMarker(frame.text, pluginConfig);
+    const maintenanceReply = checkpoint.runId ? null : await tryHandleA2AMaintenanceMarker(frame.text, pluginConfig);
     if (maintenanceReply) {
-      if (walletAddress) {
-        await supervisorClient.sendChatReply({ convId: frame.convId, walletAddress, text: maintenanceReply, replyTo: frame.id });
-      }
-      return;
+      return walletAddress ? maintenanceReply : null;
     }
-    const voiceReply = await tryHandleInstalledVoiceMarker(frame.text, pluginConfig);
+    const voiceReply = checkpoint.runId ? null : await tryHandleInstalledVoiceMarker(frame.text, pluginConfig);
     if (voiceReply) {
-      if (walletAddress) {
-        await supervisorClient.sendChatReply({ convId: frame.convId, walletAddress, text: voiceReply, replyTo: frame.id });
-      }
-      return;
+      return walletAddress ? voiceReply : null;
     }
     const marker = `[PERKOS_CHAT:${frame.convId}]`;
     const recentPage = await chatStore?.readPage(frame.convId, {
@@ -30544,38 +31098,60 @@ function register(api) {
     ].filter(Boolean).join("\n");
     const runtimeKind = pluginConfig.runtime?.kind || "openclaw";
     if (usesHttpDelivery(runtimeKind)) {
-      try {
-        await deliverToHermes(pluginConfig, eventText, logger);
-      } catch (err) {
-        logger.error(`[perkos-chat] hermes delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+      if (autoReplyEnabled()) {
+        const response = await deliverToHermes(pluginConfig, directRunPrompt, true, chatSessionKey(frame.convId), checkpoint);
+        const text = extractAssistantText(response);
+        if (!text) throw new Error("CHAT_RUNTIME_EMPTY_FINAL");
+        return text;
       }
-      return;
+      await deliverToHermes2(pluginConfig, eventText, logger);
+      return null;
     }
     if (runtimeKind === "none") {
       logger.info(`[perkos-chat] dropped chat_deliver for ${frame.convId} (runtime=none)`);
-      return;
+      return null;
     }
-    const chatSessionKey = openclawChatSessionKey(pluginConfig, frame.convId);
-    await prepareOpenClawChatSession(api, pluginConfig, chatSessionKey, logger);
+    const chatSessionKey2 = openclawChatSessionKey(pluginConfig, frame.convId);
+    await prepareOpenClawChatSession(api, pluginConfig, chatSessionKey2, logger);
     if (walletAddress) {
-      const embeddedReply = await runOpenClawChatTurn(api, pluginConfig, chatSessionKey, directRunPrompt, frame.text, logger);
+      const embeddedReply = await runOpenClawChatTurn(api, pluginConfig, chatSessionKey2, directRunPrompt, frame.text, logger);
       const reply = embeddedReply ? stripPerkosChatTransportMarker(embeddedReply, frame.convId) : null;
       if (reply) {
-        const result = await supervisorClient.sendChatReply({
-          convId: frame.convId,
-          walletAddress,
-          text: reply,
-          replyTo: frame.id
-        });
-        logger.info(`[perkos-chat] embedded reply ${result.delivered ? "delivered" : "queued (offline)"} for ${frame.convId}`);
-        return;
+        return reply;
       }
       if (embeddedReply) {
-        logger.error(`[perkos-chat] embedded OpenClaw reply contained only transport metadata for ${frame.convId}`);
+        throw new Error("CHAT_RUNTIME_EMPTY_FINAL");
       }
     }
-    if (enqueueSystemEvent) enqueueSystemEvent(eventText, { sessionKey: chatSessionKey });
-    wakeGatewayAgent(requestHeartbeatNow, `[PerkOS-Chat] inbound message in ${frame.convId}`, logger, chatSessionKey);
+    if (enqueueSystemEvent) enqueueSystemEvent(eventText, { sessionKey: chatSessionKey2 });
+    wakeGatewayAgent(requestHeartbeatNow, `[PerkOS-Chat] inbound message in ${frame.convId}`, logger, chatSessionKey2);
+    return null;
+  };
+  const chatTurns = chatStore ? new ChatTurns({
+    root: chatStore.root,
+    owner: pluginConfig.agentName,
+    execute: executeSupervisorChat,
+    error: (code) => logger.error(`[perkos-chat] ${code}`),
+    progress: (frame, phase) => {
+      const walletAddress = parseWalletFromIdentity(frame.from);
+      if (walletAddress) void supervisorClient.sendChatProgress({ convId: frame.convId, walletAddress, replyTo: frame.id, phase }).catch(() => {
+      });
+    },
+    reply: (turn, id) => {
+      const walletAddress = parseWalletFromIdentity(turn.frame.from);
+      if (!walletAddress) throw new Error("CHAT_REPLY_CONTEXT_UNAVAILABLE");
+      return supervisorClient.sendChatReply({
+        id,
+        convId: turn.frame.convId,
+        walletAddress,
+        text: turn.text,
+        replyTo: turn.frame.id,
+        timestamp: turn.completedAt
+      });
+    }
+  }) : null;
+  const handleSupervisorChatDeliver = async (frame) => {
+    if (chatTurns) await chatTurns.submit(frame);
   };
   if (pluginConfig.chat?.enabled && !chatApiKey) {
     logger.error("[perkos-chat] chat.enabled=true but no apiKey (set chat.apiKey or fall back from relay.apiKey)");
@@ -30622,6 +31198,7 @@ function register(api) {
     start: async () => {
       try {
         await supervisorClient.start();
+        await chatTurns?.start();
         void flushMaintenanceReceipts(pluginConfig);
         const ownerHealth = supervisorClient.currentHealth();
         recordRuntimeLoadEvidence({