@mndrk/agx 2.0.32 → 2.0.33

package/cloud-runtime/standalone/worker/index.js

@@ -86,20 +86,20 @@ var require_file_uri_to_path = __commonJS({
       var rest = decodeURI(uri.substring(7));
       var firstSlash = rest.indexOf("/");
       var host = rest.substring(0, firstSlash);
-      var path8 = rest.substring(firstSlash + 1);
+      var path10 = rest.substring(firstSlash + 1);
       if ("localhost" == host) host = "";
       if (host) {
         host = sep + sep + host;
       }
-      path8 = path8.replace(/^(.+)\|/, "$1:");
+      path10 = path10.replace(/^(.+)\|/, "$1:");
       if (sep == "\\") {
-        path8 = path8.replace(/\//g, "\\");
+        path10 = path10.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path8)) {
+      if (/^.+\:/.test(path10)) {
       } else {
-        path8 = sep + path8;
+        path10 = sep + path10;
       }
-      return host + path8;
+      return host + path10;
     }
   }
 });
@@ -107,19 +107,19 @@ var require_file_uri_to_path = __commonJS({
 // ../agx-cloud/node_modules/bindings/bindings.js
 var require_bindings = __commonJS({
   "../agx-cloud/node_modules/bindings/bindings.js"(exports2, module2) {
-    var fs5 = require("fs");
-    var path8 = require("path");
+    var fs7 = require("fs");
+    var path10 = require("path");
     var fileURLToPath = require_file_uri_to_path();
-    var join6 = path8.join;
-    var dirname = path8.dirname;
-    var exists = fs5.accessSync && function(path9) {
+    var join6 = path10.join;
+    var dirname = path10.dirname;
+    var exists = fs7.accessSync && function(path11) {
       try {
-        fs5.accessSync(path9);
+        fs7.accessSync(path11);
       } catch (e) {
         return false;
       }
       return true;
-    } || fs5.existsSync || path8.existsSync;
+    } || fs7.existsSync || path10.existsSync;
     var defaults = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -164,7 +164,7 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports2.getRoot(exports2.getFileName());
       }
-      if (path8.extname(opts.bindings) != ".node") {
+      if (path10.extname(opts.bindings) != ".node") {
         opts.bindings += ".node";
       }
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
@@ -402,11 +402,11 @@ var require_pragma = __commonJS({
 var require_backup = __commonJS({
   "../agx-cloud/node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
     "use strict";
-    var fs5 = require("fs");
-    var path8 = require("path");
+    var fs7 = require("fs");
+    var path10 = require("path");
     var { promisify } = require("util");
     var { cppdb } = require_util();
-    var fsAccess = promisify(fs5.access);
+    var fsAccess = promisify(fs7.access);
     module2.exports = async function backup(filename, options) {
       if (options == null) options = {};
       if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
@@ -419,7 +419,7 @@ var require_backup = __commonJS({
       if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
       if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
       if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
-      await fsAccess(path8.dirname(filename)).catch(() => {
+      await fsAccess(path10.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -724,8 +724,8 @@ var require_inspect = __commonJS({
 var require_database = __commonJS({
   "../agx-cloud/node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
     "use strict";
-    var fs5 = require("fs");
-    var path8 = require("path");
+    var fs7 = require("fs");
+    var path10 = require("path");
     var util = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
@@ -761,7 +761,7 @@ var require_database = __commonJS({
         addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
       } else if (typeof nativeBinding === "string") {
         const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
-        addon = requireFunc(path8.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path10.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
         addon = nativeBinding;
       }
@@ -769,7 +769,7 @@ var require_database = __commonJS({
         addon.setErrorConstructor(SqliteError);
         addon.isInitialized = true;
       }
-      if (!anonymous && !filename.startsWith("file:") && !fs5.existsSync(path8.dirname(filename))) {
+      if (!anonymous && !filename.startsWith("file:") && !fs7.existsSync(path10.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -977,11 +977,11 @@ var init_auth_mode = __esm({
 
 // ../agx-cloud/lib/mesh-core/activity.ts
 function activityPath(agentId) {
-  return (0, import_path3.join)(AGENTS_DIR, agentId, "activity.jsonl");
+  return (0, import_path4.join)(AGENTS_DIR, agentId, "activity.jsonl");
 }
 function ensureDir(agentId) {
-  const dir = (0, import_path3.join)(AGENTS_DIR, agentId);
-  if (!(0, import_fs3.existsSync)(dir)) (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path4.join)(AGENTS_DIR, agentId);
+  if (!(0, import_fs4.existsSync)(dir)) (0, import_fs4.mkdirSync)(dir, { recursive: true });
 }
 function logActivity(agentId, action, data) {
   try {
@@ -992,32 +992,32 @@ function logActivity(agentId, action, data) {
       action,
       ...data
     };
-    (0, import_fs3.appendFileSync)(activityPath(agentId), JSON.stringify(event) + "\n", "utf-8");
+    (0, import_fs4.appendFileSync)(activityPath(agentId), JSON.stringify(event) + "\n", "utf-8");
   } catch {
   }
 }
-var import_fs3, import_path3, import_os3, AGENTS_DIR;
+var import_fs4, import_path4, import_os4, AGENTS_DIR;
 var init_activity = __esm({
   "../agx-cloud/lib/mesh-core/activity.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path3 = require("path");
-    import_os3 = require("os");
-    AGENTS_DIR = (0, import_path3.join)((0, import_os3.homedir)(), ".agx", "agents");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
+    import_os4 = require("os");
+    AGENTS_DIR = (0, import_path4.join)((0, import_os4.homedir)(), ".agx", "agents");
   }
 });
 
 // ../agx-cloud/lib/mesh-core/self.ts
 function selfPath(agentId) {
-  return (0, import_path4.join)(AGENTS_DIR2, agentId, "self.md");
+  return (0, import_path5.join)(AGENTS_DIR2, agentId, "self.md");
 }
 function reflectionStatePath(agentId) {
-  return (0, import_path4.join)(AGENTS_DIR2, agentId, "reflection-state.json");
+  return (0, import_path5.join)(AGENTS_DIR2, agentId, "reflection-state.json");
 }
 function readSelf(agentId) {
-  const path8 = selfPath(agentId);
-  if (!(0, import_fs4.existsSync)(path8)) return null;
-  const raw = (0, import_fs4.readFileSync)(path8, "utf-8");
+  const path10 = selfPath(agentId);
+  if (!(0, import_fs5.existsSync)(path10)) return null;
+  const raw = (0, import_fs5.readFileSync)(path10, "utf-8");
   if (!raw.trim()) return null;
   const lines = raw.split("\n");
   let version = 0;
@@ -1043,8 +1043,8 @@ function readSelf(agentId) {
   };
 }
 function writeSelf(agentId, content, version) {
-  const dir = (0, import_path4.join)(AGENTS_DIR2, agentId);
-  if (!(0, import_fs4.existsSync)(dir)) (0, import_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path5.join)(AGENTS_DIR2, agentId);
+  if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
   const derivedAt = (/* @__PURE__ */ new Date()).toISOString();
   const full = `---
 version: ${version}
@@ -1053,15 +1053,15 @@ derivedAt: ${derivedAt}
 ${content}
 `;
   const tmp = selfPath(agentId) + ".tmp";
-  (0, import_fs4.writeFileSync)(tmp, full, "utf-8");
-  (0, import_fs4.renameSync)(tmp, selfPath(agentId));
+  (0, import_fs5.writeFileSync)(tmp, full, "utf-8");
+  (0, import_fs5.renameSync)(tmp, selfPath(agentId));
   logActivity(agentId, "self-updated", { meta: { version } });
 }
 function readReflectionState(agentId) {
-  const path8 = reflectionStatePath(agentId);
-  if (!(0, import_fs4.existsSync)(path8)) return null;
+  const path10 = reflectionStatePath(agentId);
+  if (!(0, import_fs5.existsSync)(path10)) return null;
   try {
-    const parsed = JSON.parse((0, import_fs4.readFileSync)(path8, "utf-8"));
+    const parsed = JSON.parse((0, import_fs5.readFileSync)(path10, "utf-8"));
     const lastProcessedJournalId = typeof parsed?.lastProcessedJournalId === "string" && parsed.lastProcessedJournalId.trim() ? parsed.lastProcessedJournalId.trim() : null;
     const updatedAt = typeof parsed?.updatedAt === "string" && parsed.updatedAt.trim() ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
     return { lastProcessedJournalId, updatedAt };
@@ -1070,11 +1070,11 @@ function readReflectionState(agentId) {
   }
 }
 function writeReflectionState(agentId, state) {
-  const dir = (0, import_path4.join)(AGENTS_DIR2, agentId);
-  if (!(0, import_fs4.existsSync)(dir)) (0, import_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path5.join)(AGENTS_DIR2, agentId);
+  if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
   const tmp = reflectionStatePath(agentId) + ".tmp";
-  (0, import_fs4.writeFileSync)(tmp, JSON.stringify(state, null, 2), "utf-8");
-  (0, import_fs4.renameSync)(tmp, reflectionStatePath(agentId));
+  (0, import_fs5.writeFileSync)(tmp, JSON.stringify(state, null, 2), "utf-8");
+  (0, import_fs5.renameSync)(tmp, reflectionStatePath(agentId));
 }
 function buildReflectionPrompt(identity, currentSelf, recentJournal, teamSelves) {
   const selfText = currentSelf?.content || `I am ${identity.name}. ${identity.seed}`;
@@ -1153,35 +1153,35 @@ Rules:
 - If nothing genuinely new was learned, return an empty memories array.
 - Do not wrap the JSON in markdown fences.`;
 }
-var import_fs4, import_path4, import_os4, AGENTS_DIR2;
+var import_fs5, import_path5, import_os5, AGENTS_DIR2;
 var init_self = __esm({
   "../agx-cloud/lib/mesh-core/self.ts"() {
     "use strict";
-    import_fs4 = require("fs");
-    import_path4 = require("path");
-    import_os4 = require("os");
+    import_fs5 = require("fs");
+    import_path5 = require("path");
+    import_os5 = require("os");
     init_activity();
-    AGENTS_DIR2 = (0, import_path4.join)((0, import_os4.homedir)(), ".agx", "agents");
+    AGENTS_DIR2 = (0, import_path5.join)((0, import_os5.homedir)(), ".agx", "agents");
   }
 });
 
 // ../agx-cloud/lib/mesh-core/journal.ts
 function agentDir(agentId) {
-  return (0, import_path5.join)(AGENTS_DIR3, agentId);
+  return (0, import_path6.join)(AGENTS_DIR3, agentId);
 }
 function journalPath(agentId) {
-  return (0, import_path5.join)(agentDir(agentId), "journal.jsonl");
+  return (0, import_path6.join)(agentDir(agentId), "journal.jsonl");
 }
 function ensureAgentDir(agentId) {
   const dir = agentDir(agentId);
-  if (!(0, import_fs5.existsSync)(dir)) {
-    (0, import_fs5.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_fs6.existsSync)(dir)) {
+    (0, import_fs6.mkdirSync)(dir, { recursive: true });
   }
 }
 function readJournalLines(agentId) {
-  const path8 = journalPath(agentId);
-  if (!(0, import_fs5.existsSync)(path8)) return [];
-  return (0, import_fs5.readFileSync)(path8, "utf-8").split("\n").filter((l) => l.trim());
+  const path10 = journalPath(agentId);
+  if (!(0, import_fs6.existsSync)(path10)) return [];
+  return (0, import_fs6.readFileSync)(path10, "utf-8").split("\n").filter((l) => l.trim());
 }
 function parseMaxSeq(agentId, lines) {
   let maxSeq = 0;
@@ -1210,7 +1210,7 @@ function appendJournal(agentId, entry) {
   const nextId = `${agentId}:${maxSeq + 1}`;
   const normalized = { ...entry, id: entry.id?.trim() || nextId };
   const line = JSON.stringify(normalized) + "\n";
-  (0, import_fs5.appendFileSync)(journalPath(agentId), line, "utf-8");
+  (0, import_fs6.appendFileSync)(journalPath(agentId), line, "utf-8");
   logActivity(agentId, entry.type === "reflection" ? "reflection" : "journal-post", {
     thread: normalized.thread,
     meta: { entryId: normalized.id }
@@ -1244,42 +1244,42 @@ function readJournalSince(agentId, afterEntryId) {
   }
   return entries;
 }
-var import_fs5, import_path5, import_os5, AGENTS_DIR3;
+var import_fs6, import_path6, import_os6, AGENTS_DIR3;
 var init_journal = __esm({
   "../agx-cloud/lib/mesh-core/journal.ts"() {
     "use strict";
-    import_fs5 = require("fs");
-    import_path5 = require("path");
-    import_os5 = require("os");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
+    import_os6 = require("os");
     init_activity();
-    AGENTS_DIR3 = (0, import_path5.join)((0, import_os5.homedir)(), ".agx", "agents");
+    AGENTS_DIR3 = (0, import_path6.join)((0, import_os6.homedir)(), ".agx", "agents");
   }
 });
 
 // ../agx-cloud/lib/mesh-core/agent.ts
 function ensureAgent(agentId, options) {
-  const dir = (0, import_path6.join)(AGENTS_DIR4, agentId);
-  if (!(0, import_fs6.existsSync)(dir)) {
-    (0, import_fs6.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path7.join)(AGENTS_DIR4, agentId);
+  if (!(0, import_fs7.existsSync)(dir)) {
+    (0, import_fs7.mkdirSync)(dir, { recursive: true });
   }
   const voice = options?.voice?.trim() || DEFAULT_VOICE;
   const seed = options?.seed?.trim() || DEFAULT_SEED;
-  const identityPath = (0, import_path6.join)(dir, "identity.json");
-  if (!(0, import_fs6.existsSync)(identityPath)) {
+  const identityPath = (0, import_path7.join)(dir, "identity.json");
+  if (!(0, import_fs7.existsSync)(identityPath)) {
     const identity = { name: agentId, voice, seed };
-    (0, import_fs6.writeFileSync)(identityPath, JSON.stringify(identity, null, 2) + "\n", "utf-8");
-  }
-  const journal = (0, import_path6.join)(dir, "journal.jsonl");
-  const reactions = (0, import_path6.join)(dir, "reactions.jsonl");
-  const comments = (0, import_path6.join)(dir, "comments.jsonl");
-  const activity = (0, import_path6.join)(dir, "activity.jsonl");
-  const self = (0, import_path6.join)(dir, "self.md");
-  if (!(0, import_fs6.existsSync)(journal)) (0, import_fs6.writeFileSync)(journal, "", "utf-8");
-  if (!(0, import_fs6.existsSync)(reactions)) (0, import_fs6.writeFileSync)(reactions, "", "utf-8");
-  if (!(0, import_fs6.existsSync)(comments)) (0, import_fs6.writeFileSync)(comments, "", "utf-8");
-  if (!(0, import_fs6.existsSync)(activity)) (0, import_fs6.writeFileSync)(activity, "", "utf-8");
-  if (!(0, import_fs6.existsSync)(self)) {
-    (0, import_fs6.writeFileSync)(
+    (0, import_fs7.writeFileSync)(identityPath, JSON.stringify(identity, null, 2) + "\n", "utf-8");
+  }
+  const journal = (0, import_path7.join)(dir, "journal.jsonl");
+  const reactions = (0, import_path7.join)(dir, "reactions.jsonl");
+  const comments = (0, import_path7.join)(dir, "comments.jsonl");
+  const activity = (0, import_path7.join)(dir, "activity.jsonl");
+  const self = (0, import_path7.join)(dir, "self.md");
+  if (!(0, import_fs7.existsSync)(journal)) (0, import_fs7.writeFileSync)(journal, "", "utf-8");
+  if (!(0, import_fs7.existsSync)(reactions)) (0, import_fs7.writeFileSync)(reactions, "", "utf-8");
+  if (!(0, import_fs7.existsSync)(comments)) (0, import_fs7.writeFileSync)(comments, "", "utf-8");
+  if (!(0, import_fs7.existsSync)(activity)) (0, import_fs7.writeFileSync)(activity, "", "utf-8");
+  if (!(0, import_fs7.existsSync)(self)) {
+    (0, import_fs7.writeFileSync)(
       self,
       `---
 version: 0
@@ -1292,31 +1292,31 @@ I am ${agentId}. ${seed}
   }
 }
 function readIdentity(agentId) {
-  const path8 = (0, import_path6.join)(AGENTS_DIR4, agentId, "identity.json");
-  if (!(0, import_fs6.existsSync)(path8)) return null;
+  const path10 = (0, import_path7.join)(AGENTS_DIR4, agentId, "identity.json");
+  if (!(0, import_fs7.existsSync)(path10)) return null;
   try {
-    return JSON.parse((0, import_fs6.readFileSync)(path8, "utf-8"));
+    return JSON.parse((0, import_fs7.readFileSync)(path10, "utf-8"));
   } catch {
     return null;
   }
 }
 function listAgents() {
-  if (!(0, import_fs6.existsSync)(AGENTS_DIR4)) return [];
-  return (0, import_fs6.readdirSync)(AGENTS_DIR4, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!(0, import_fs7.existsSync)(AGENTS_DIR4)) return [];
+  return (0, import_fs7.readdirSync)(AGENTS_DIR4, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
 }
 function getTeamSelves(excludeAgent) {
   return listAgents().filter((id) => id !== excludeAgent).map((id) => readSelf(id)).filter((s) => s !== null);
 }
-var import_fs6, import_path6, import_os6, AGENTS_DIR4, DEFAULT_VOICE, DEFAULT_SEED;
+var import_fs7, import_path7, import_os7, AGENTS_DIR4, DEFAULT_VOICE, DEFAULT_SEED;
 var init_agent = __esm({
   "../agx-cloud/lib/mesh-core/agent.ts"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path6 = require("path");
-    import_os6 = require("os");
+    import_fs7 = require("fs");
+    import_path7 = require("path");
+    import_os7 = require("os");
     init_self();
     init_journal();
-    AGENTS_DIR4 = (0, import_path6.join)((0, import_os6.homedir)(), ".agx", "agents");
+    AGENTS_DIR4 = (0, import_path7.join)((0, import_os7.homedir)(), ".agx", "agents");
     DEFAULT_VOICE = "conversational, concise, practical";
     DEFAULT_SEED = "I evolve through experience and collaboration.";
   }
@@ -1338,20 +1338,20 @@ function nextUniqueId(base, used) {
 }
 function migrateAgentDirectory(oldId, newId, displayName) {
   if (!oldId || !newId || oldId === newId) return;
-  const oldDir = import_path7.default.join(AGENTS_DIR5, oldId);
-  const newDir = import_path7.default.join(AGENTS_DIR5, newId);
-  if (!(0, import_fs7.existsSync)(oldDir) || (0, import_fs7.existsSync)(newDir)) return;
-  (0, import_fs7.mkdirSync)(AGENTS_DIR5, { recursive: true });
-  (0, import_fs7.renameSync)(oldDir, newDir);
-  const identityPath = import_path7.default.join(newDir, "identity.json");
-  if (!(0, import_fs7.existsSync)(identityPath)) return;
+  const oldDir = import_path8.default.join(AGENTS_DIR5, oldId);
+  const newDir = import_path8.default.join(AGENTS_DIR5, newId);
+  if (!(0, import_fs8.existsSync)(oldDir) || (0, import_fs8.existsSync)(newDir)) return;
+  (0, import_fs8.mkdirSync)(AGENTS_DIR5, { recursive: true });
+  (0, import_fs8.renameSync)(oldDir, newDir);
+  const identityPath = import_path8.default.join(newDir, "identity.json");
+  if (!(0, import_fs8.existsSync)(identityPath)) return;
   try {
-    const parsed = JSON.parse((0, import_fs7.readFileSync)(identityPath, "utf8"));
+    const parsed = JSON.parse((0, import_fs8.readFileSync)(identityPath, "utf8"));
     const updated = {
       ...parsed,
       name: typeof displayName === "string" && displayName.trim() ? displayName.trim() : newId
     };
-    (0, import_fs7.writeFileSync)(identityPath, `${JSON.stringify(updated, null, 2)}
+    (0, import_fs8.writeFileSync)(identityPath, `${JSON.stringify(updated, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -1429,7 +1429,7 @@ function migrateLegacyParticipantIds(db2) {
   }
 }
 function getDb() {
-  (0, import_fs7.mkdirSync)(STORE_DIR, { recursive: true });
+  (0, import_fs8.mkdirSync)(STORE_DIR, { recursive: true });
   const db2 = new import_better_sqlite32.default(DB_PATH);
   db2.pragma("journal_mode = WAL");
   db2.exec(`
@@ -1507,17 +1507,17 @@ function loadParticipants() {
     db2.close();
   }
 }
-var import_better_sqlite32, import_fs7, import_path7, import_os7, STORE_DIR, DB_PATH, AGENTS_DIR5;
+var import_better_sqlite32, import_fs8, import_path8, import_os8, STORE_DIR, DB_PATH, AGENTS_DIR5;
 var init_participants_store = __esm({
   "../agx-cloud/lib/participants-store.ts"() {
     "use strict";
     import_better_sqlite32 = __toESM(require_lib());
-    import_fs7 = require("fs");
-    import_path7 = __toESM(require("path"));
-    import_os7 = __toESM(require("os"));
-    STORE_DIR = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path7.default.join(import_os7.default.homedir(), ".agx", "group-chat");
-    DB_PATH = import_path7.default.join(STORE_DIR, "history.sqlite");
-    AGENTS_DIR5 = process.env.AGX_AGENTS_DIR?.trim() || import_path7.default.join(import_os7.default.homedir(), ".agx", "agents");
+    import_fs8 = require("fs");
+    import_path8 = __toESM(require("path"));
+    import_os8 = __toESM(require("os"));
+    STORE_DIR = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path8.default.join(import_os8.default.homedir(), ".agx", "group-chat");
+    DB_PATH = import_path8.default.join(STORE_DIR, "history.sqlite");
+    AGENTS_DIR5 = process.env.AGX_AGENTS_DIR?.trim() || import_path8.default.join(import_os8.default.homedir(), ".agx", "agents");
   }
 });
 
@@ -1811,7 +1811,7 @@ function sqlExpr(expr) {
 }
 function getSQLiteDb() {
   if (_db) return _db;
-  const dbPath = process.env.SQLITE_DB_PATH || import_path8.default.join(AGX_DATA_DIR2, "agx-board.db");
+  const dbPath = process.env.SQLITE_DB_PATH || import_path9.default.join(AGX_DATA_DIR3, "agx-board.db");
   _db = new import_better_sqlite33.default(dbPath);
   const errors = validateSQLiteEnvironment(_db, dbPath);
   if (errors.length > 0) {
@@ -1837,12 +1837,12 @@ ${msgs.join("\n")}`);
   return _db;
 }
 function initSQLiteSchema(db2) {
-  const ddlPath = import_path8.default.join(process.cwd(), "db", "sqlite", "001_agx_board_schema.sql");
-  if (!import_fs8.default.existsSync(ddlPath)) {
+  const ddlPath = import_path9.default.join(process.cwd(), "db", "sqlite", "001_agx_board_schema.sql");
+  if (!import_fs9.default.existsSync(ddlPath)) {
     console.warn(`[sqlite] DDL not found at ${ddlPath}, skipping schema init`);
     return;
   }
-  const ddl = import_fs8.default.readFileSync(ddlPath, "utf-8");
+  const ddl = import_fs9.default.readFileSync(ddlPath, "utf-8");
   db2.exec(ddl);
 }
 function dropLegacyTeamsTables(db2) {
@@ -2244,20 +2244,20 @@ function createAdminDbClientSQLite() {
     }
   };
 }
-var import_better_sqlite33, import_fs8, import_path8, import_os8, AGX_DATA_DIR2, SqlExpression, _db, JSON_COLUMNS, SQLiteQueryBuilder, KNOWN_JSON_COLUMNS;
+var import_better_sqlite33, import_fs9, import_path9, import_os9, AGX_DATA_DIR3, SqlExpression, _db, JSON_COLUMNS, SQLiteQueryBuilder, KNOWN_JSON_COLUMNS;
 var init_sqlite_query_adapter = __esm({
   "../agx-cloud/lib/sqlite-query-adapter.ts"() {
     "use strict";
     import_better_sqlite33 = __toESM(require_lib());
-    import_fs8 = __toESM(require("fs"));
-    import_path8 = __toESM(require("path"));
-    import_os8 = __toESM(require("os"));
+    import_fs9 = __toESM(require("fs"));
+    import_path9 = __toESM(require("path"));
+    import_os9 = __toESM(require("os"));
     init_auth_mode();
     init_agent();
     init_participants_store();
     init_startup();
     init_workspaces_to_projects_migration();
-    AGX_DATA_DIR2 = process.env.AGX_DATA_DIR || import_path8.default.join(import_os8.default.homedir(), ".agx");
+    AGX_DATA_DIR3 = process.env.AGX_DATA_DIR || import_path9.default.join(import_os9.default.homedir(), ".agx");
     SqlExpression = class {
       constructor(expr) {
         this.expr = expr;
@@ -4061,7 +4061,7 @@ async function deleteProjectMemory(memoryId) {
 }
 async function getProjectThreads(projectId) {
   const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_threads").select("*").eq("project_id", projectId).order("created_at", { ascending: false });
+  const { data, error } = await db2.from("project_threads").select("*").eq("project_id", projectId).order("created_at", { ascending: true });
   if (error) {
     if (isMissingRelationError2(error, "project_threads")) return [];
     throw error;
@@ -4527,9 +4527,9 @@ function v4(options, buf, offset) {
 var v4_default = v4;
 
 // ../agx-cloud/lib/queue/sqlite-adapter.ts
-var import_path2 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
-var import_os2 = __toESM(require("os"));
+var import_path3 = __toESM(require("path"));
+var import_fs3 = __toESM(require("fs"));
+var import_os3 = __toESM(require("os"));
 init_startup();
 
 // ../agx-cloud/lib/limits.ts
@@ -4570,8 +4570,53 @@ var WriteRateMonitor = class {
   }
 };
 
-// ../agx-cloud/lib/queue/sqlite-adapter.ts
+// ../agx-cloud/lib/debug-log.ts
+var import_fs2 = __toESM(require("fs"));
+var import_os2 = __toESM(require("os"));
+var import_path2 = __toESM(require("path"));
 var AGX_DATA_DIR = process.env.AGX_DATA_DIR || import_path2.default.join(import_os2.default.homedir(), ".agx");
+var DEBUG_LOG_PATH = process.env.AGX_DEBUG_LOG_PATH || import_path2.default.join(AGX_DATA_DIR, "logs", "desktop-chat-debug.log");
+function ensureLogDir() {
+  import_fs2.default.mkdirSync(import_path2.default.dirname(DEBUG_LOG_PATH), { recursive: true });
+}
+function safeReplacer(_key, value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  if (typeof value === "string" && value.length > 2e3) {
+    return `${value.slice(0, 2e3)}...<truncated>`;
+  }
+  return value;
+}
+function writeDebugLog(event, payload) {
+  try {
+    ensureLogDir();
+    const line = JSON.stringify(
+      {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        pid: process.pid,
+        event,
+        ...payload ? { payload } : {}
+      },
+      safeReplacer
+    );
+    import_fs2.default.appendFileSync(DEBUG_LOG_PATH, `${line}
+`, "utf8");
+  } catch {
+  }
+}
+
+// ../agx-cloud/lib/queue/sqlite-adapter.ts
+var AGX_DATA_DIR2 = process.env.AGX_DATA_DIR || import_path3.default.join(import_os3.default.homedir(), ".agx");
+var DEFAULT_STALE_JOB_TIMEOUT_MS = 10 * 60 * 1e3;
+function getStaleJobTimeoutMs() {
+  const raw = Number(process.env.AGX_QUEUE_STALE_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_STALE_JOB_TIMEOUT_MS;
+}
 var SQLiteQueueAdapter = class {
   constructor(dbPath) {
     this.workers = /* @__PURE__ */ new Map();
@@ -4579,10 +4624,10 @@ var SQLiteQueueAdapter = class {
     this.writeRateInterval = null;
     this.writeMonitor = new WriteRateMonitor();
     this.workerId = v4_default();
-    const finalPath = dbPath || process.env.SQLITE_QUEUE_PATH || import_path2.default.join(AGX_DATA_DIR, "agx-queue.db");
-    const dir = import_path2.default.dirname(finalPath);
-    if (!import_fs2.default.existsSync(dir)) {
-      import_fs2.default.mkdirSync(dir, { recursive: true });
+    const finalPath = dbPath || process.env.SQLITE_QUEUE_PATH || import_path3.default.join(AGX_DATA_DIR2, "agx-queue.db");
+    const dir = import_path3.default.dirname(finalPath);
+    if (!import_fs3.default.existsSync(dir)) {
+      import_fs3.default.mkdirSync(dir, { recursive: true });
     }
     this.db = new import_better_sqlite3.default(finalPath);
     const errors = validateSQLiteEnvironment(this.db, finalPath);
@@ -4647,9 +4692,23 @@ var SQLiteQueueAdapter = class {
       options?.priority ?? 0
     );
     this.writeMonitor.record();
+    writeDebugLog("queue.send", {
+      queue: queue2,
+      jobId: id,
+      startAfter,
+      retryLimit: options?.retryLimit ?? 3,
+      priority: options?.priority ?? 0,
+      data
+    });
     return id;
   }
   async work(queue2, handler, options) {
+    writeDebugLog("queue.worker.register", {
+      queue: queue2,
+      batchSize: options?.batchSize ?? 1,
+      pollInterval: options?.pollInterval ?? null,
+      workerId: this.workerId
+    });
     this.workers.set(queue2, {
       handler,
       options: options || {},
@@ -4680,7 +4739,17 @@ var SQLiteQueueAdapter = class {
   processQueue(queue2, worker) {
     const batchSize = worker.options.batchSize || 1;
     const now = Date.now();
+    const staleBefore = now - getStaleJobTimeoutMs();
     const jobs = this.db.transaction(() => {
+      const reapedJobs = this.reapStaleJobs(queue2, now, staleBefore);
+      if (reapedJobs.length > 0) {
+        writeDebugLog("queue.reap_stale", {
+          queue: queue2,
+          workerId: this.workerId,
+          staleBefore,
+          jobs: reapedJobs
+        });
+      }
       const candidates = this.db.prepare(`
         SELECT id, data FROM agx_jobs
         WHERE queue = ?
@@ -4706,6 +4775,11 @@ var SQLiteQueueAdapter = class {
       }));
     })();
     if (jobs.length > 0) {
+      writeDebugLog("queue.claim", {
+        queue: queue2,
+        workerId: this.workerId,
+        jobIds: jobs.map((job) => job.id)
+      });
       this.executeJobs(jobs, worker.handler);
     }
   }
@@ -4713,15 +4787,22 @@ var SQLiteQueueAdapter = class {
     try {
       await handler(jobs);
       this.completeJobs(jobs.map((j) => j.id));
+      writeDebugLog("queue.complete", {
+        jobIds: jobs.map((job) => job.id)
+      });
     } catch (err) {
       this.failJobs(jobs.map((j) => j.id), err.message || String(err));
+      writeDebugLog("queue.fail", {
+        jobIds: jobs.map((job) => job.id),
+        error: err
+      });
     }
   }
   completeJobs(ids) {
     const now = Date.now();
     const stmt = this.db.prepare(`
       UPDATE agx_jobs
-      SET status = 'completed', completed_at = ?
+      SET status = 'completed', completed_at = ?, worker_id = NULL
       WHERE id = ?
     `);
     this.db.transaction(() => {
@@ -4737,12 +4818,14 @@ var SQLiteQueueAdapter = class {
       UPDATE agx_jobs
       SET status = 'retry', retry_count = retry_count + 1, 
           start_after = ? + (retry_count * 1000 * 2), -- Exponential backoff (kinda)
+          started_at = NULL,
+          worker_id = NULL,
           error = ?
       WHERE id = ?
     `);
     const updateFailed = this.db.prepare(`
       UPDATE agx_jobs
-      SET status = 'failed', failed_at = ?, error = ?
+      SET status = 'failed', failed_at = ?, started_at = NULL, worker_id = NULL, error = ?
       WHERE id = ?
     `);
     this.db.transaction(() => {
@@ -4757,6 +4840,59 @@ var SQLiteQueueAdapter = class {
       }
     })();
   }
+  reapStaleJobs(queue2, now, staleBefore) {
+    const staleJobs = this.db.prepare(`
+      SELECT id, retry_count, retry_limit
+      FROM agx_jobs
+      WHERE queue = ?
+        AND status = 'active'
+        AND started_at IS NOT NULL
+        AND started_at <= ?
+      ORDER BY started_at ASC
+    `).all(queue2, staleBefore);
+    if (staleJobs.length === 0) return [];
+    const updateRetry = this.db.prepare(`
+      UPDATE agx_jobs
+      SET status = 'retry',
+          retry_count = retry_count + 1,
+          start_after = ?,
+          started_at = NULL,
+          worker_id = NULL,
+          error = ?
+      WHERE id = ?
+    `);
+    const updateFailed = this.db.prepare(`
+      UPDATE agx_jobs
+      SET status = 'failed',
+          failed_at = ?,
+          started_at = NULL,
+          worker_id = NULL,
+          error = ?
+      WHERE id = ?
+    `);
+    const reaped = [];
+    for (const job of staleJobs) {
+      const error = `Job exceeded active timeout of ${getStaleJobTimeoutMs()}ms`;
+      if (job.retry_count < job.retry_limit) {
+        updateRetry.run(now, error, job.id);
+        reaped.push({
+          id: job.id,
+          fromStatus: "active",
+          toStatus: "retry",
+          retryCount: job.retry_count + 1
+        });
+      } else {
+        updateFailed.run(now, error, job.id);
+        reaped.push({
+          id: job.id,
+          fromStatus: "active",
+          toStatus: "failed",
+          retryCount: job.retry_count
+        });
+      }
+    }
+    return reaped;
+  }
 };
 
 // ../agx-cloud/lib/queue/boss.ts
@@ -5018,6 +5154,8 @@ var import_crypto4 = require("crypto");
 
 // ../agx-cloud/lib/cli-runner.ts
 var import_child_process = require("child_process");
+var import_fs10 = __toESM(require("fs"));
+var import_path10 = __toESM(require("path"));
 
 // ../agx-cloud/lib/sanitize.ts
 function createCliChunkSanitizer() {
@@ -5296,15 +5434,177 @@ var createThoughtFilterParser = (inner) => {
     }
   };
 };
+var AGX_WRAPPED_PROVIDERS = /* @__PURE__ */ new Set([
+  "claude",
+  "gemini",
+  "ollama",
+  "codex"
+]);
+function providerNativeCommand({
+  provider,
+  model,
+  prompt,
+  systemPrompt
+}) {
+  switch (provider) {
+    case "claude": {
+      const args = [
+        "-p",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages"
+      ];
+      if (model) args.push("--model", model);
+      if (systemPrompt) args.push("--system-prompt", systemPrompt);
+      args.push(prompt);
+      return { command: "claude", args, parser: "claude-stream-json" };
+    }
+    case "gemini":
+      return {
+        command: "gemini",
+        args: ["--yolo", "-p", systemPrompt ? `${systemPrompt}
+
+${prompt}` : prompt, "-o", "stream-json"],
+        parser: "gemini-stream-json"
+      };
+    case "ollama":
+      return {
+        command: "ollama",
+        args: ["run", model || "llama3.2", systemPrompt ? `${systemPrompt}
+
+${prompt}` : prompt],
+        parser: "raw"
+      };
+    case "codex": {
+      const codexArgs = ["exec", "--json"];
+      if (model) codexArgs.push("--model", model);
+      codexArgs.push(systemPrompt ? `${systemPrompt}
+
+${prompt}` : prompt);
+      return {
+        command: "codex",
+        args: codexArgs,
+        parser: "codex-json"
+      };
+    }
+    case "zai": {
+      const zaiApiKey = process.env.ZAI_API_KEY?.trim();
+      const zaiArgs = [
+        "-p",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages"
+      ];
+      if (model) zaiArgs.push("--model", model);
+      if (systemPrompt) zaiArgs.push("--system-prompt", systemPrompt);
+      zaiArgs.push(prompt);
+      return {
+        command: "claude",
+        args: zaiArgs,
+        parser: "claude-stream-json",
+        env: {
+          ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
+          ...zaiApiKey ? { ANTHROPIC_AUTH_TOKEN: zaiApiKey } : {}
+        }
+      };
+    }
+    default:
+      return null;
+  }
+}
 function agxCommandForProvider({
   provider,
   model,
-  prompt
+  prompt,
+  passthroughArgs
 }) {
   const args = [provider, "-y", "--print", "--prompt", prompt];
   if (model) args.push("--model", model);
+  if (passthroughArgs && passthroughArgs.length > 0) {
+    args.push("--", ...passthroughArgs);
+  }
   return { command: "agx", args, parser: "raw" };
 }
+function resolveBundledCliPath() {
+  const explicit = process.env.AGX_CLI_PATH?.trim();
+  if (explicit && import_fs10.default.existsSync(explicit)) return explicit;
+  const candidates = [
+    import_path10.default.resolve(process.cwd(), "..", "cli", "index.js"),
+    import_path10.default.resolve(__dirname, "..", "cli", "index.js"),
+    import_path10.default.resolve(process.execPath, "..", "..", "Resources", "cli", "index.js")
+  ];
+  for (const candidate of candidates) {
+    if (import_fs10.default.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function buildCliAttempts({
+  provider,
+  model,
+  prompt,
+  systemPrompt,
+  passthroughArgs
+}, deps = {}) {
+  const exists = deps.commandExists ?? commandExists;
+  const bundledCliPath = deps.bundledCliPath === void 0 ? resolveBundledCliPath() : deps.bundledCliPath;
+  const attempts = [];
+  const agxPrompt = systemPrompt ? `${systemPrompt}
+
+${prompt}` : prompt;
+  if (AGX_WRAPPED_PROVIDERS.has(provider)) {
+    const bundledAgx = bundledAgxCommandForProvider({
+      provider,
+      model,
+      prompt: agxPrompt,
+      cliPath: bundledCliPath,
+      passthroughArgs
+    });
+    if (bundledAgx) {
+      attempts.push(bundledAgx);
+    }
+    if (exists("agx")) {
+      attempts.push(
+        agxCommandForProvider({
+          provider,
+          model,
+          prompt: agxPrompt,
+          passthroughArgs
+        })
+      );
+    }
+    return attempts;
+  }
+  const nativeAttempt = providerNativeCommand({
+    provider,
+    model,
+    prompt,
+    systemPrompt
+  });
+  if (nativeAttempt && exists(nativeAttempt.command)) {
+    attempts.push(nativeAttempt);
+  }
+  return attempts;
+}
+function bundledAgxCommandForProvider({
+  provider,
+  model,
+  prompt,
+  cliPath,
+  passthroughArgs
+}) {
+  const resolvedCliPath = cliPath === void 0 ? resolveBundledCliPath() : cliPath;
+  if (!resolvedCliPath) return null;
+  const args = [resolvedCliPath, provider, "-y", "--print", "--prompt", prompt];
+  if (model) args.push("--model", model);
+  if (passthroughArgs && passthroughArgs.length > 0) {
+    args.push("--", ...passthroughArgs);
+  }
+  return { command: process.execPath, args, parser: "raw" };
+}
 async function runCommandStreamed({
   command,
   args,
@@ -5316,6 +5616,13 @@ async function runCommandStreamed({
   env: extraEnv
 }) {
   await new Promise((resolve, reject) => {
+    writeDebugLog("cli-runner.spawn", {
+      command,
+      args,
+      timeoutMs,
+      bundledCliPath: resolveBundledCliPath(),
+      isElectron: process.env.AGX_ELECTRON || null
+    });
     if (onLog) onLog("stderr", `$ ${command} ${args.map((a) => a.length > 80 ? a.slice(0, 80) + "\u2026" : a).join(" ")}
 `);
     const child = (0, import_child_process.spawn)(command, args, {
@@ -5334,13 +5641,29 @@ async function runCommandStreamed({
       else resolve();
     };
     const onAbort = () => {
+      writeDebugLog("cli-runner.abort", {
+        command,
+        args,
+        pid: child.pid ?? null
+      });
       child.kill("SIGTERM");
       finalize(new Error("Chat request aborted."));
     };
     if (signal) signal.addEventListener("abort", onAbort, { once: true });
     if (onSpawn && child.pid) onSpawn(child.pid);
+    writeDebugLog("cli-runner.spawned", {
+      command,
+      args,
+      pid: child.pid ?? null
+    });
     const timer = setTimeout(() => {
       timedOut = true;
+      writeDebugLog("cli-runner.timeout", {
+        command,
+        args,
+        pid: child.pid ?? null,
+        timeoutMs
+      });
       child.kill("SIGKILL");
       finalize(new Error(`CLI request timed out after ${timeoutMs}ms.`));
     }, timeoutMs);
@@ -5355,9 +5678,24 @@ async function runCommandStreamed({
       combinedOutput += str;
       if (onLog) onLog("stderr", str);
     });
-    child.on("error", (error) => finalize(error));
+    child.on("error", (error) => {
+      writeDebugLog("cli-runner.process_error", {
+        command,
+        args,
+        pid: child.pid ?? null,
+        error
+      });
+      finalize(error);
+    });
     child.on("close", (code, childSignal) => {
       if (done || timedOut) return;
+      writeDebugLog("cli-runner.close", {
+        command,
+        args,
+        pid: child.pid ?? null,
+        code: code ?? null,
+        signal: childSignal ?? null
+      });
       if (code === 0) {
         finalize();
         return;
@@ -5378,6 +5716,7 @@ async function runCliResponse({
   self,
   skills,
   systemContext,
+  passthroughArgs,
   signal,
   onDelta,
   onLog,
@@ -5389,7 +5728,6 @@ async function runCliResponse({
     const cleaned = sanitize(chunk);
     if (cleaned) onDelta(cleaned);
   };
-  const attempts = [];
   const systemParts = [];
   if (systemContext) systemParts.push(systemContext);
   if (identity) systemParts.push(`<identity>
@@ -5402,19 +5740,33 @@ ${self}
 ${skills}
 </skills>`);
   const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
-  if (commandExists("agx")) {
-    const agxPrompt = systemPrompt ? `${systemPrompt}
-
-${prompt}` : prompt;
-    attempts.push(agxCommandForProvider({ provider, model, prompt: agxPrompt }));
-  }
+  const attempts = buildCliAttempts({
+    provider,
+    model,
+    prompt,
+    systemPrompt,
+    passthroughArgs
+  });
   if (attempts.length === 0) {
+    writeDebugLog("cli-runner.no_attempts", {
+      provider,
+      model,
+      bundledCliPath: resolveBundledCliPath(),
+      isElectron: process.env.AGX_ELECTRON || null
+    });
     throw new Error(
       `No CLI runner available for provider "${provider}". Install agx or provider CLI.`
     );
   }
   let lastError = null;
   for (const attempt of attempts) {
+    writeDebugLog("cli-runner.attempt", {
+      provider,
+      model,
+      command: attempt.command,
+      args: attempt.args,
+      parser: attempt.parser
+    });
     const baseParser = attempt.parser === "claude-stream-json" ? createClaudeStreamJsonParser(wrappedOnDelta) : attempt.parser === "codex-json" ? createCodexJsonParser(wrappedOnDelta) : attempt.parser === "gemini-stream-json" ? createGeminiStreamJsonParser(wrappedOnDelta) : createRawParser(wrappedOnDelta);
     const parser = attempt.filterThoughts ? createThoughtFilterParser(baseParser) : baseParser;
     try {
@@ -5429,9 +5781,20 @@ ${prompt}` : prompt;
         env: attempt.env
       });
       parser.flush();
+      writeDebugLog("cli-runner.success", {
+        provider,
+        model,
+        command: attempt.command
+      });
       return;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
+      writeDebugLog("cli-runner.failure", {
+        provider,
+        model,
+        command: attempt.command,
+        error: lastError
+      });
     }
   }
   throw lastError || new Error("CLI execution failed.");
@@ -6497,11 +6860,11 @@ var import_promises = require("fs/promises");
 
 // ../agx-cloud/lib/agent-process-registry.ts
 var import_better_sqlite34 = __toESM(require_lib());
-var import_path9 = __toESM(require("path"));
-var import_os9 = __toESM(require("os"));
-var import_fs9 = require("fs");
-var HISTORY_DIR = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path9.default.join(import_os9.default.homedir(), ".agx", "group-chat");
-var DB_PATH2 = import_path9.default.join(HISTORY_DIR, "history.sqlite");
+var import_path11 = __toESM(require("path"));
+var import_os10 = __toESM(require("os"));
+var import_fs11 = require("fs");
+var HISTORY_DIR = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path11.default.join(import_os10.default.homedir(), ".agx", "group-chat");
+var DB_PATH2 = import_path11.default.join(HISTORY_DIR, "history.sqlite");
 function toEntry(row) {
   return {
     id: row.id,
@@ -6518,7 +6881,7 @@ function toEntry(row) {
   };
 }
 function getDb2() {
-  (0, import_fs9.mkdirSync)(HISTORY_DIR, { recursive: true });
+  (0, import_fs11.mkdirSync)(HISTORY_DIR, { recursive: true });
   const db2 = new import_better_sqlite34.default(DB_PATH2);
   db2.pragma("journal_mode = WAL");
   db2.exec(`
@@ -6673,11 +7036,11 @@ function killByWorkspace(workspaceId) {
 
 // ../agx-cloud/lib/history-store.ts
 var import_better_sqlite35 = __toESM(require_lib());
-var import_fs10 = require("fs");
-var import_path10 = __toESM(require("path"));
-var import_os10 = __toESM(require("os"));
-var HISTORY_DIR2 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path10.default.join(import_os10.default.homedir(), ".agx", "group-chat");
-var DB_PATH3 = import_path10.default.join(HISTORY_DIR2, "history.sqlite");
+var import_fs12 = require("fs");
+var import_path12 = __toESM(require("path"));
+var import_os11 = __toESM(require("os"));
+var HISTORY_DIR2 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path12.default.join(import_os11.default.homedir(), ".agx", "group-chat");
+var DB_PATH3 = import_path12.default.join(HISTORY_DIR2, "history.sqlite");
 var LEGACY_THREAD_ID = "global";
 var REACTION_TYPES = /* @__PURE__ */ new Set([
   "ack",
@@ -6686,6 +7049,8 @@ var REACTION_TYPES = /* @__PURE__ */ new Set([
   "clarify",
   "blocked"
 ]);
+var ACTIVE_AGENT_PROCESS_STALE_MS = 10 * 60 * 1e3;
+var ACTIVE_CHAT_RUN_STALE_MS = 10 * 60 * 1e3;
 var ALLOWED_TRANSITIONS = {
   ack: /* @__PURE__ */ new Set(["ack", "working"]),
   working: /* @__PURE__ */ new Set(["ack", "working", "done", "clarify", "blocked"]),
@@ -6906,7 +7271,7 @@ function migrateLegacyTables(db2) {
   migrateLogsToAgentProcessId(db2);
 }
 var withDatabase = async (run) => {
-  await import_fs10.promises.mkdir(HISTORY_DIR2, { recursive: true });
+  await import_fs12.promises.mkdir(HISTORY_DIR2, { recursive: true });
   const db2 = new import_better_sqlite35.default(DB_PATH3);
   db2.pragma("journal_mode = WAL");
   try {
@@ -7088,7 +7453,31 @@ async function saveMessages(threadId, messages) {
     insertMany(messages);
   });
 }
+async function sweepStaleChatRuns(input) {
+  const normalizedThreadId = normalizeOptionalText(input?.threadId ?? null);
+  const thresholdMs = Number.isFinite(input?.olderThanMs) ? Math.max(input.olderThanMs, 1) : ACTIVE_CHAT_RUN_STALE_MS;
+  const now = Date.now();
+  const cutoff = now - thresholdMs;
+  return withDatabase((db2) => {
+    const clauses = ["status = 'running'", "updated_at <= ?"];
+    const params = [cutoff];
+    if (normalizedThreadId) {
+      clauses.push("thread_id = ?");
+      params.push(normalizedThreadId);
+    }
+    const result = db2.prepare(
+      `UPDATE chat_runs
+         SET status = 'failed',
+             last_error = COALESCE(NULLIF(last_error, ''), 'Worker process died mid-execution'),
+             updated_at = ?,
+             completed_at = COALESCE(completed_at, ?)
+         WHERE ${clauses.join(" AND ")}`
+    ).run(now, now, ...params);
+    return result.changes;
+  });
+}
 async function getChatRun(chatRunId) {
+  await sweepStaleChatRuns();
   return withDatabase((db2) => {
     const row = db2.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(chatRunId);
     return row ? toChatRunRecord(row) : null;
@@ -7336,11 +7725,11 @@ function parseReactionSignals(content) {
 
 // ../agx-cloud/lib/attachment-store.ts
 var import_better_sqlite36 = __toESM(require_lib());
-var import_path11 = __toESM(require("path"));
-var import_os11 = __toESM(require("os"));
-var HISTORY_DIR3 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path11.default.join(import_os11.default.homedir(), ".agx", "group-chat");
-var DB_PATH4 = import_path11.default.join(HISTORY_DIR3, "history.sqlite");
-var UPLOADS_DIR = import_path11.default.join(HISTORY_DIR3, "uploads");
+var import_path13 = __toESM(require("path"));
+var import_os12 = __toESM(require("os"));
+var HISTORY_DIR3 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path13.default.join(import_os12.default.homedir(), ".agx", "group-chat");
+var DB_PATH4 = import_path13.default.join(HISTORY_DIR3, "history.sqlite");
+var UPLOADS_DIR = import_path13.default.join(HISTORY_DIR3, "uploads");
 function getDb3() {
   const db2 = new import_better_sqlite36.default(DB_PATH4);
   db2.pragma("journal_mode = WAL");
@@ -7380,7 +7769,7 @@ async function getAttachmentMeta(id) {
     ).get(id);
     if (!row) return null;
     const diskName = row.disk_name || id;
-    return { filename: row.filename, mimeType: row.mime_type, size: row.size, diskPath: import_path11.default.join(UPLOADS_DIR, diskName) };
+    return { filename: row.filename, mimeType: row.mime_type, size: row.size, diskPath: import_path13.default.join(UPLOADS_DIR, diskName) };
   } finally {
     db2.close();
   }
@@ -7393,18 +7782,18 @@ init_journal();
 init_agent();
 
 // ../agx-cloud/lib/mesh-core/reactions.ts
-var import_fs11 = require("fs");
-var import_path12 = require("path");
-var import_os12 = require("os");
+var import_fs13 = require("fs");
+var import_path14 = require("path");
+var import_os13 = require("os");
 init_journal();
 init_activity();
-var AGENTS_DIR6 = (0, import_path12.join)((0, import_os12.homedir)(), ".agx", "agents");
+var AGENTS_DIR6 = (0, import_path14.join)((0, import_os13.homedir)(), ".agx", "agents");
 function reactionsPath(agentId) {
-  return (0, import_path12.join)(AGENTS_DIR6, agentId, "reactions.jsonl");
+  return (0, import_path14.join)(AGENTS_DIR6, agentId, "reactions.jsonl");
 }
 function ensureDir2(agentId) {
-  const dir = (0, import_path12.join)(AGENTS_DIR6, agentId);
-  if (!(0, import_fs11.existsSync)(dir)) (0, import_fs11.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path14.join)(AGENTS_DIR6, agentId);
+  if (!(0, import_fs13.existsSync)(dir)) (0, import_fs13.mkdirSync)(dir, { recursive: true });
 }
 function targetEntryExists(targetEntry) {
   const [targetAgent] = targetEntry.split(":");
@@ -7423,7 +7812,7 @@ function appendReaction(agentId, targetEntry, type) {
     targetEntry,
     type
   };
-  (0, import_fs11.appendFileSync)(reactionsPath(agentId), JSON.stringify(reaction) + "\n", "utf-8");
+  (0, import_fs13.appendFileSync)(reactionsPath(agentId), JSON.stringify(reaction) + "\n", "utf-8");
   logActivity(agentId, "mesh-reaction", { meta: { target: targetEntry, type } });
 }
 
@@ -8501,15 +8890,31 @@ function isChatRunPayload(value) {
   );
 }
 async function handleStart2(job) {
+  writeDebugLog("chat-processor.start.received", {
+    jobId: job.id,
+    chatRunId: job.data.chatRunId,
+    signal: job.data.signal
+  });
   const chatRun = await loadChatRunActivity(job.data.chatRunId);
   if (!chatRun) {
+    writeDebugLog("chat-processor.start.missing", {
+      chatRunId: job.data.chatRunId,
+      jobId: job.id
+    });
     console.warn(`[chat-processor] Chat run ${job.data.chatRunId} not found, skipping`);
     return;
   }
   if (chatRun.status === "completed" || chatRun.status === "failed" || chatRun.status === "cancelled") {
+    writeDebugLog("chat-processor.start.skip_terminal", {
+      chatRunId: chatRun.id,
+      status: chatRun.status
+    });
     return;
   }
   if (!isChatRunPayload(chatRun.payload)) {
+    writeDebugLog("chat-processor.start.invalid_payload", {
+      chatRunId: chatRun.id
+    });
     await updateChatRunActivity({
       id: chatRun.id,
       status: "failed",
@@ -8536,10 +8941,20 @@ async function handleStart2(job) {
     lastError: null
   });
   try {
+    writeDebugLog("chat-processor.start.running", {
+      chatRunId: chatRun.id,
+      threadId: chatRun.threadId,
+      rootMessageId: chatRun.rootMessageId,
+      participantIds: chatRun.payload.participantIds
+    });
     const library = await loadDbParticipants();
     const participantIdSet = new Set(chatRun.payload.participantIds);
     const participants = chatRun.payload.participantIds.map((participantId) => library.find((participant) => participant.id === participantId)).filter((participant) => Boolean(participant));
     if (participants.length === 0) {
+      writeDebugLog("chat-processor.start.no_participants_resolved", {
+        chatRunId: chatRun.id,
+        participantIds: chatRun.payload.participantIds
+      });
       throw new Error("No participants resolved for chat run");
     }
     const mentioned = new Set(
@@ -8561,10 +8976,17 @@ async function handleStart2(job) {
       rootMessageId: chatRun.payload.rootMessageId
     });
     const reader = stream.getReader();
+    writeDebugLog("chat-processor.stream.open", {
+      chatRunId: chatRun.id,
+      participantCount: participants.length
+    });
     while (true) {
       const { done } = await reader.read();
       if (done) break;
     }
+    writeDebugLog("chat-processor.stream.complete", {
+      chatRunId: chatRun.id
+    });
     await completeChatRunStepActivity({
       stepId: step.id,
       status: "completed",
@@ -8582,8 +9004,17 @@ async function handleStart2(job) {
         rootMessageId: chatRun.payload.rootMessageId
       }
     });
+    writeDebugLog("chat-processor.complete", {
+      chatRunId: chatRun.id,
+      rootMessageId: chatRun.payload.rootMessageId
+    });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    writeDebugLog("chat-processor.error", {
+      chatRunId: chatRun.id,
+      error,
+      message
+    });
     await completeChatRunStepActivity({
       stepId: step.id,
       status: "failed",
@@ -8599,6 +9030,10 @@ async function handleStart2(job) {
   }
 }
 async function handleCancel2(job) {
+  writeDebugLog("chat-processor.cancel.received", {
+    jobId: job.id,
+    chatRunId: job.data.chatRunId
+  });
   const chatRun = await loadChatRunActivity(job.data.chatRunId);
   if (!chatRun) return;
   if (chatRun.rootMessageId) {
@@ -8613,6 +9048,10 @@ async function handleCancel2(job) {
     completedAt: Date.now(),
     result: { cancelled: true }
   });
+  writeDebugLog("chat-processor.cancel.complete", {
+    chatRunId: chatRun.id,
+    threadId: chatRun.threadId
+  });
 }
 async function processSingleJob2(job) {
   switch (job.data.signal) {