@mndrk/agx 2.0.25 → 2.0.32

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 path5 = rest.substring(firstSlash + 1);
+      var path8 = rest.substring(firstSlash + 1);
       if ("localhost" == host) host = "";
       if (host) {
         host = sep + sep + host;
       }
-      path5 = path5.replace(/^(.+)\|/, "$1:");
+      path8 = path8.replace(/^(.+)\|/, "$1:");
       if (sep == "\\") {
-        path5 = path5.replace(/\//g, "\\");
+        path8 = path8.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path5)) {
+      if (/^.+\:/.test(path8)) {
       } else {
-        path5 = sep + path5;
+        path8 = sep + path8;
       }
-      return host + path5;
+      return host + path8;
     }
   }
 });
@@ -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 fs4 = require("fs");
-    var path5 = require("path");
+    var fs5 = require("fs");
+    var path8 = require("path");
     var fileURLToPath = require_file_uri_to_path();
-    var join5 = path5.join;
-    var dirname = path5.dirname;
-    var exists = fs4.accessSync && function(path6) {
+    var join6 = path8.join;
+    var dirname = path8.dirname;
+    var exists = fs5.accessSync && function(path9) {
       try {
-        fs4.accessSync(path6);
+        fs5.accessSync(path9);
       } catch (e) {
         return false;
       }
       return true;
-    } || fs4.existsSync || path5.existsSync;
+    } || fs5.existsSync || path8.existsSync;
     var defaults = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -164,13 +164,13 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports2.getRoot(exports2.getFileName());
       }
-      if (path5.extname(opts.bindings) != ".node") {
+      if (path8.extname(opts.bindings) != ".node") {
         opts.bindings += ".node";
       }
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
       var tries = [], i = 0, l = opts.try.length, n, b, err;
       for (; i < l; i++) {
-        n = join5.apply(
+        n = join6.apply(
           null,
           opts.try[i].map(function(p) {
             return opts[p] || p;
@@ -231,7 +231,7 @@ var require_bindings = __commonJS({
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
+        if (exists(join6(dir, "package.json")) || exists(join6(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -240,7 +240,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join5(dir, "..");
+        dir = join6(dir, "..");
       }
     };
   }
@@ -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 fs4 = require("fs");
-    var path5 = require("path");
+    var fs5 = require("fs");
+    var path8 = require("path");
     var { promisify } = require("util");
     var { cppdb } = require_util();
-    var fsAccess = promisify(fs4.access);
+    var fsAccess = promisify(fs5.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(path5.dirname(filename)).catch(() => {
+      await fsAccess(path8.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -712,7 +712,7 @@ var require_table = __commonJS({
 var require_inspect = __commonJS({
   "../agx-cloud/node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
     "use strict";
-    var DatabaseInspection = function Database4() {
+    var DatabaseInspection = function Database7() {
     };
     module2.exports = function inspect(depth, opts) {
       return Object.assign(new DatabaseInspection(), this);
@@ -724,14 +724,14 @@ var require_inspect = __commonJS({
 var require_database = __commonJS({
   "../agx-cloud/node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
     "use strict";
-    var fs4 = require("fs");
-    var path5 = require("path");
+    var fs5 = require("fs");
+    var path8 = require("path");
     var util = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
-    function Database4(filenameGiven, options) {
+    function Database7(filenameGiven, options) {
       if (new.target == null) {
-        return new Database4(filenameGiven, options);
+        return new Database7(filenameGiven, options);
       }
       let buffer;
       if (Buffer.isBuffer(filenameGiven)) {
@@ -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(path5.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path8.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:") && !fs4.existsSync(path5.dirname(filename))) {
+      if (!anonymous && !filename.startsWith("file:") && !fs5.existsSync(path8.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -778,21 +778,21 @@ var require_database = __commonJS({
       });
     }
     var wrappers = require_wrappers();
-    Database4.prototype.prepare = wrappers.prepare;
-    Database4.prototype.transaction = require_transaction();
-    Database4.prototype.pragma = require_pragma();
-    Database4.prototype.backup = require_backup();
-    Database4.prototype.serialize = require_serialize();
-    Database4.prototype.function = require_function();
-    Database4.prototype.aggregate = require_aggregate();
-    Database4.prototype.table = require_table();
-    Database4.prototype.loadExtension = wrappers.loadExtension;
-    Database4.prototype.exec = wrappers.exec;
-    Database4.prototype.close = wrappers.close;
-    Database4.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database4.prototype.unsafeMode = wrappers.unsafeMode;
-    Database4.prototype[util.inspect] = require_inspect();
-    module2.exports = Database4;
+    Database7.prototype.prepare = wrappers.prepare;
+    Database7.prototype.transaction = require_transaction();
+    Database7.prototype.pragma = require_pragma();
+    Database7.prototype.backup = require_backup();
+    Database7.prototype.serialize = require_serialize();
+    Database7.prototype.function = require_function();
+    Database7.prototype.aggregate = require_aggregate();
+    Database7.prototype.table = require_table();
+    Database7.prototype.loadExtension = wrappers.loadExtension;
+    Database7.prototype.exec = wrappers.exec;
+    Database7.prototype.close = wrappers.close;
+    Database7.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database7.prototype.unsafeMode = wrappers.unsafeMode;
+    Database7.prototype[util.inspect] = require_inspect();
+    module2.exports = Database7;
   }
 });
 
@@ -976,10 +976,31 @@ var init_auth_mode = __esm({
 });
 
 // ../agx-cloud/lib/mesh-core/activity.ts
-var import_path3, import_os3, AGENTS_DIR;
+function activityPath(agentId) {
+  return (0, import_path3.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 });
+}
+function logActivity(agentId, action, data) {
+  try {
+    ensureDir(agentId);
+    const event = {
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: agentId,
+      action,
+      ...data
+    };
+    (0, import_fs3.appendFileSync)(activityPath(agentId), JSON.stringify(event) + "\n", "utf-8");
+  } catch {
+  }
+}
+var import_fs3, import_path3, import_os3, 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");
@@ -987,10 +1008,156 @@ var init_activity = __esm({
 });
 
 // ../agx-cloud/lib/mesh-core/self.ts
-var import_path4, import_os4, AGENTS_DIR2;
+function selfPath(agentId) {
+  return (0, import_path4.join)(AGENTS_DIR2, agentId, "self.md");
+}
+function reflectionStatePath(agentId) {
+  return (0, import_path4.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");
+  if (!raw.trim()) return null;
+  const lines = raw.split("\n");
+  let version = 0;
+  let derivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let contentStart = 0;
+  if (lines[0] === "---") {
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i] === "---") {
+        contentStart = i + 1;
+        break;
+      }
+      const [key, ...rest] = lines[i].split(": ");
+      const val = rest.join(": ");
+      if (key === "version") version = parseInt(val, 10) || 0;
+      if (key === "derivedAt") derivedAt = val;
+    }
+  }
+  return {
+    agentId,
+    content: lines.slice(contentStart).join("\n").trim(),
+    version,
+    derivedAt
+  };
+}
+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 derivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const full = `---
+version: ${version}
+derivedAt: ${derivedAt}
+---
+${content}
+`;
+  const tmp = selfPath(agentId) + ".tmp";
+  (0, import_fs4.writeFileSync)(tmp, full, "utf-8");
+  (0, import_fs4.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;
+  try {
+    const parsed = JSON.parse((0, import_fs4.readFileSync)(path8, "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 };
+  } catch {
+    return null;
+  }
+}
+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 tmp = reflectionStatePath(agentId) + ".tmp";
+  (0, import_fs4.writeFileSync)(tmp, JSON.stringify(state, null, 2), "utf-8");
+  (0, import_fs4.renameSync)(tmp, reflectionStatePath(agentId));
+}
+function buildReflectionPrompt(identity, currentSelf, recentJournal, teamSelves) {
+  const selfText = currentSelf?.content || `I am ${identity.name}. ${identity.seed}`;
+  const journalText = recentJournal.map((e) => {
+    const parts = [`- [${e.t}] ${e.observation}`];
+    if (e.judgement) parts.push(`  Judgement: ${e.judgement}`);
+    if (e.comparison) parts.push(`  Comparison: ${e.comparison}`);
+    if (e.delta) parts.push(`  Delta: ${e.delta}`);
+    if (e.intent) parts.push(`  Intent: ${e.intent}`);
+    return parts.join("\n");
+  }).join("\n");
+  const teamText = teamSelves.filter((s) => s.agentId !== identity.name).map((s) => `### ${s.agentId}
+${s.content}`).join("\n\n");
+  return `You are ${identity.name}. Voice: ${identity.voice}.
+
+## Canonical Identity
+${identity.seed}
+
+## Current Self-Model (v${currentSelf?.version ?? 0})
+${selfText}
+
+## Recent Journal Entries (since last reflection)
+These entries are evidence about how you worked. Treat them as signals, not ground truth. Use them to identify patterns in execution, coordination, inquiry, and specialization. Do NOT repeat or reference specific technical content from past conversations.
+${journalText || "(none)"}
+
+## Team \u2014 Other Agents' Current Self-Models
+${teamText || "(no other agents)"}
+
+## Instructions
+Write your updated self-model. This is not canonical identity. It is your current understanding of how you best contribute, where you fit in the team, and what specialization you should lean into next.
+
+Consider:
+- What patterns are emerging in your work?
+- What kind of work do you reliably do well?
+- Where are you overlapping too much with other agents?
+- What role or niche seems under-covered in this team?
+- How should you specialize further in this project context?
+
+Do NOT reference specific files, functions, or technical details from past conversations. Focus on your evolving capabilities and working style.
+
+Write in first person. Be specific about your strengths, gaps, comparative fit, and next direction. This is not a summary and not an autobiography. It is a concise specialization-oriented self-model. Keep it under 200 words.`;
+}
+function formatKnowledgeLines(existingMemories) {
+  if (existingMemories.length === 0) return "(none)";
+  return existingMemories.map((entry) => `- [${entry.kind}] ${entry.title}: ${entry.body}`).join("\n");
+}
+function buildStructuredReflectionPrompt(identity, currentSelf, recentJournal, teamSelves, existingMemories) {
+  const selfPrompt = buildReflectionPrompt(identity, currentSelf, recentJournal, teamSelves);
+  return `${selfPrompt}
+
+## Existing Agent Memories
+${formatKnowledgeLines(existingMemories)}
+
+## Output Format
+Return ONLY a JSON object with this exact shape:
+{
+  "self_model": "updated self-model text",
+  "memories": [
+    {
+      "kind": "pattern" | "preference" | "constraint" | "decision" | "lesson" | "gotcha",
+      "title": "short title",
+      "body": "one concise durable behavior-level memory",
+      "confidence": 0.0,
+      "durability": 0.0,
+      "tags": ["optional", "tags"],
+      "evidence": [{"id":"journal-entry-id","note":"short evidence note"}]
+    }
+  ]
+}
+
+Rules:
+- Emit 0-3 memories.
+- Memories must be durable behavior-level insights about how you work best, collaborate, decide, or fail repeatedly.
+- Do not include task-specific technical facts unless they clearly generalize into agent behavior.
+- Do not restate memories already covered in Existing Agent Memories.
+- 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 init_self = __esm({
   "../agx-cloud/lib/mesh-core/self.ts"() {
     "use strict";
+    import_fs4 = require("fs");
     import_path4 = require("path");
     import_os4 = require("os");
     init_activity();
@@ -999,10 +1166,89 @@ var init_self = __esm({
 });
 
 // ../agx-cloud/lib/mesh-core/journal.ts
-var import_path5, import_os5, AGENTS_DIR3;
+function agentDir(agentId) {
+  return (0, import_path5.join)(AGENTS_DIR3, agentId);
+}
+function journalPath(agentId) {
+  return (0, import_path5.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 });
+  }
+}
+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());
+}
+function parseMaxSeq(agentId, lines) {
+  let maxSeq = 0;
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      const [idAgent, seqRaw] = String(parsed.id || "").split(":");
+      if (idAgent !== agentId) continue;
+      const seq = parseInt(seqRaw || "0", 10);
+      if (Number.isFinite(seq) && seq > maxSeq) maxSeq = seq;
+    } catch {
+    }
+  }
+  return maxSeq;
+}
+function parseEntrySeq(agentId, entryId) {
+  const [idAgent, seqRaw] = String(entryId || "").split(":");
+  if (idAgent !== agentId) return 0;
+  const seq = parseInt(seqRaw || "0", 10);
+  return Number.isFinite(seq) ? seq : 0;
+}
+function appendJournal(agentId, entry) {
+  ensureAgentDir(agentId);
+  const lines = readJournalLines(agentId);
+  const maxSeq = parseMaxSeq(agentId, lines);
+  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");
+  logActivity(agentId, entry.type === "reflection" ? "reflection" : "journal-post", {
+    thread: normalized.thread,
+    meta: { entryId: normalized.id }
+  });
+  return normalized;
+}
+function readJournal(agentId, limit) {
+  const lines = readJournalLines(agentId);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  entries.reverse();
+  return limit ? entries.slice(0, limit) : entries;
+}
+function readJournalSince(agentId, afterEntryId) {
+  const lines = readJournalLines(agentId);
+  const afterSeq = parseEntrySeq(agentId, afterEntryId);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (parseEntrySeq(agentId, parsed.id) > afterSeq) {
+        entries.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+var import_fs5, import_path5, import_os5, 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");
     init_activity();
@@ -1013,27 +1259,27 @@ var init_journal = __esm({
 // ../agx-cloud/lib/mesh-core/agent.ts
 function ensureAgent(agentId, options) {
   const dir = (0, import_path6.join)(AGENTS_DIR4, agentId);
-  if (!(0, import_fs3.existsSync)(dir)) {
-    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_fs6.existsSync)(dir)) {
+    (0, import_fs6.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_fs3.existsSync)(identityPath)) {
+  if (!(0, import_fs6.existsSync)(identityPath)) {
     const identity = { name: agentId, voice, seed };
-    (0, import_fs3.writeFileSync)(identityPath, JSON.stringify(identity, null, 2) + "\n", "utf-8");
+    (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_fs3.existsSync)(journal)) (0, import_fs3.writeFileSync)(journal, "", "utf-8");
-  if (!(0, import_fs3.existsSync)(reactions)) (0, import_fs3.writeFileSync)(reactions, "", "utf-8");
-  if (!(0, import_fs3.existsSync)(comments)) (0, import_fs3.writeFileSync)(comments, "", "utf-8");
-  if (!(0, import_fs3.existsSync)(activity)) (0, import_fs3.writeFileSync)(activity, "", "utf-8");
-  if (!(0, import_fs3.existsSync)(self)) {
-    (0, import_fs3.writeFileSync)(
+  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)(
       self,
       `---
 version: 0
@@ -1046,23 +1292,26 @@ I am ${agentId}. ${seed}
   }
 }
 function readIdentity(agentId) {
-  const path5 = (0, import_path6.join)(AGENTS_DIR4, agentId, "identity.json");
-  if (!(0, import_fs3.existsSync)(path5)) return null;
+  const path8 = (0, import_path6.join)(AGENTS_DIR4, agentId, "identity.json");
+  if (!(0, import_fs6.existsSync)(path8)) return null;
   try {
-    return JSON.parse((0, import_fs3.readFileSync)(path5, "utf-8"));
+    return JSON.parse((0, import_fs6.readFileSync)(path8, "utf-8"));
   } catch {
     return null;
   }
 }
 function listAgents() {
-  if (!(0, import_fs3.existsSync)(AGENTS_DIR4)) return [];
-  return (0, import_fs3.readdirSync)(AGENTS_DIR4, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  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);
+}
+function getTeamSelves(excludeAgent) {
+  return listAgents().filter((id) => id !== excludeAgent).map((id) => readSelf(id)).filter((s) => s !== null);
 }
-var import_fs3, import_path6, import_os6, AGENTS_DIR4, DEFAULT_VOICE, DEFAULT_SEED;
+var import_fs6, import_path6, import_os6, AGENTS_DIR4, DEFAULT_VOICE, DEFAULT_SEED;
 var init_agent = __esm({
   "../agx-cloud/lib/mesh-core/agent.ts"() {
     "use strict";
-    import_fs3 = require("fs");
+    import_fs6 = require("fs");
     import_path6 = require("path");
     import_os6 = require("os");
     init_self();
@@ -1091,18 +1340,18 @@ 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_fs4.existsSync)(oldDir) || (0, import_fs4.existsSync)(newDir)) return;
-  (0, import_fs4.mkdirSync)(AGENTS_DIR5, { recursive: true });
-  (0, import_fs4.renameSync)(oldDir, newDir);
+  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_fs4.existsSync)(identityPath)) return;
+  if (!(0, import_fs7.existsSync)(identityPath)) return;
   try {
-    const parsed = JSON.parse((0, import_fs4.readFileSync)(identityPath, "utf8"));
+    const parsed = JSON.parse((0, import_fs7.readFileSync)(identityPath, "utf8"));
     const updated = {
       ...parsed,
       name: typeof displayName === "string" && displayName.trim() ? displayName.trim() : newId
     };
-    (0, import_fs4.writeFileSync)(identityPath, `${JSON.stringify(updated, null, 2)}
+    (0, import_fs7.writeFileSync)(identityPath, `${JSON.stringify(updated, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -1180,7 +1429,7 @@ function migrateLegacyParticipantIds(db2) {
   }
 }
 function getDb() {
-  (0, import_fs4.mkdirSync)(STORE_DIR, { recursive: true });
+  (0, import_fs7.mkdirSync)(STORE_DIR, { recursive: true });
   const db2 = new import_better_sqlite32.default(DB_PATH);
   db2.pragma("journal_mode = WAL");
   db2.exec(`
@@ -1258,12 +1507,12 @@ function loadParticipants() {
     db2.close();
   }
 }
-var import_better_sqlite32, import_fs4, import_path7, import_os7, STORE_DIR, DB_PATH, AGENTS_DIR5;
+var import_better_sqlite32, import_fs7, import_path7, import_os7, 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_fs4 = require("fs");
+    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");
@@ -1589,11 +1838,11 @@ ${msgs.join("\n")}`);
 }
 function initSQLiteSchema(db2) {
   const ddlPath = import_path8.default.join(process.cwd(), "db", "sqlite", "001_agx_board_schema.sql");
-  if (!import_fs5.default.existsSync(ddlPath)) {
+  if (!import_fs8.default.existsSync(ddlPath)) {
     console.warn(`[sqlite] DDL not found at ${ddlPath}, skipping schema init`);
     return;
   }
-  const ddl = import_fs5.default.readFileSync(ddlPath, "utf-8");
+  const ddl = import_fs8.default.readFileSync(ddlPath, "utf-8");
   db2.exec(ddl);
 }
 function dropLegacyTeamsTables(db2) {
@@ -1699,6 +1948,80 @@ function runMigrations(db2) {
     CREATE INDEX IF NOT EXISTS idx_repo_knowledge_repo ON repo_knowledge (repo_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_repo_knowledge_producer ON repo_knowledge (producer);
   `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_entries (
+      id TEXT NOT NULL PRIMARY KEY,
+      scope TEXT NOT NULL CHECK(scope IN ('agent', 'repo', 'project')),
+      subject_id TEXT NOT NULL,
+      source_type TEXT NOT NULL CHECK(source_type IN ('reflection', 'thread_transition', 'task_completion')),
+      source_id TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('outcome', 'decision', 'pattern', 'gotcha', 'preference', 'constraint', 'convention', 'lesson')),
+      title TEXT NOT NULL,
+      body TEXT NOT NULL,
+      confidence REAL,
+      durability REAL,
+      tags JSON NOT NULL DEFAULT '[]',
+      evidence JSON NOT NULL DEFAULT '[]',
+      metadata JSON NOT NULL DEFAULT '{}',
+      content_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      UNIQUE(scope, subject_id, content_hash)
+    );
+    CREATE INDEX IF NOT EXISTS idx_knowledge_entries_scope_subject ON knowledge_entries (scope, subject_id, updated_at);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_entries_source ON knowledge_entries (source_type, source_id);
+  `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_notes (
+      id TEXT NOT NULL PRIMARY KEY,
+      scope TEXT NOT NULL CHECK(scope IN ('agent', 'repo', 'project')),
+      subject_id TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      change_summary TEXT,
+      source_type TEXT NOT NULL CHECK(source_type IN ('reflection', 'thread_transition', 'task_completion')),
+      source_id TEXT NOT NULL,
+      metadata JSON NOT NULL DEFAULT '{}',
+      version INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      UNIQUE(scope, subject_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_knowledge_notes_scope_subject ON knowledge_notes (scope, subject_id);
+  `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_note_versions (
+      id TEXT NOT NULL PRIMARY KEY,
+      note_id TEXT NOT NULL REFERENCES knowledge_notes(id) ON DELETE CASCADE,
+      version INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      change_summary TEXT,
+      source_type TEXT NOT NULL CHECK(source_type IN ('reflection', 'thread_transition', 'task_completion')),
+      source_id TEXT NOT NULL,
+      metadata JSON NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_knowledge_note_versions_note_version
+      ON knowledge_note_versions (note_id, version DESC);
+  `);
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS thread_knowledge_runs (
+      id TEXT NOT NULL PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      root_message_id TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('running', 'completed', 'failed')),
+      requested_scopes JSON NOT NULL DEFAULT '[]',
+      repo_inserted_count INTEGER NOT NULL DEFAULT 0,
+      project_inserted_count INTEGER NOT NULL DEFAULT 0,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      completed_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_thread_knowledge_runs_root_created
+      ON thread_knowledge_runs (root_message_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_thread_knowledge_runs_thread_created
+      ON thread_knowledge_runs (thread_id, created_at DESC);
+  `);
   db2.exec(`
     CREATE TABLE IF NOT EXISTS project_threads (
       project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
@@ -1921,12 +2244,12 @@ function createAdminDbClientSQLite() {
     }
   };
 }
-var import_better_sqlite33, import_fs5, import_path8, import_os8, AGX_DATA_DIR2, SqlExpression, _db, JSON_COLUMNS, SQLiteQueryBuilder, KNOWN_JSON_COLUMNS;
+var import_better_sqlite33, import_fs8, import_path8, import_os8, AGX_DATA_DIR2, 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_fs5 = __toESM(require("fs"));
+    import_fs8 = __toESM(require("fs"));
     import_path8 = __toESM(require("path"));
     import_os8 = __toESM(require("os"));
     init_auth_mode();
@@ -3581,6 +3904,15 @@ async function getAgent(id, userId) {
   }
   return data;
 }
+async function getAgentSkills(agentId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("agent_skills").select("*").eq("agent_id", agentId).order("created_at", { ascending: true });
+  if (error) {
+    if (isMissingRelationError2(error, "agent_skills")) return [];
+    throw error;
+  }
+  return data || [];
+}
 async function createAgent(userId, input) {
   const db2 = createAdminDbClient();
   const payload = {
@@ -4431,6 +4763,7 @@ var SQLiteQueueAdapter = class {
 var queue = null;
 var QUEUE_NAMES = {
   TASK_PROCESS: "agx.task.process",
+  CHAT_RUN_PROCESS: "agx.chat.process",
   TASK_CLEANUP: "agx.task.cleanup"
 };
 async function getQueue() {
@@ -4681,7 +5014,7 @@ async function resolveWorkflowTransition({
 init_db();
 
 // ../agx-cloud/lib/memory-extractor.ts
-var import_crypto2 = require("crypto");
+var import_crypto4 = require("crypto");
 
 // ../agx-cloud/lib/cli-runner.ts
 var import_child_process = require("child_process");
@@ -5106,6 +5439,305 @@ ${prompt}` : prompt;
 
 // ../agx-cloud/lib/memory-extractor.ts
 init_sqlite_query_adapter();
+
+// ../agx-cloud/lib/knowledge-store.ts
+var import_crypto2 = require("crypto");
+init_sqlite_query_adapter();
+function clampUnitNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(1, value));
+}
+function parseJsonArray(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parseJsonObject(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function normalizeTags(tags) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const tag of tags ?? []) {
+    const trimmed = String(tag ?? "").trim().toLowerCase();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    result.push(trimmed);
+  }
+  return result;
+}
+function normalizeEvidence(evidence) {
+  const result = [];
+  for (const item of evidence ?? []) {
+    const note = String(item?.note ?? "").trim();
+    const id = typeof item?.id === "string" ? item.id.trim() : "";
+    if (!note) continue;
+    result.push(id ? { id, note } : { note });
+  }
+  return result;
+}
+function mapRow(row) {
+  return {
+    id: row.id,
+    scope: row.scope,
+    subjectId: row.subject_id,
+    sourceType: row.source_type,
+    sourceId: row.source_id,
+    kind: row.kind,
+    title: row.title,
+    body: row.body,
+    confidence: clampUnitNumber(row.confidence),
+    durability: clampUnitNumber(row.durability),
+    tags: parseJsonArray(row.tags),
+    evidence: parseJsonArray(row.evidence),
+    metadata: parseJsonObject(row.metadata),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function listKnowledgeEntries(input) {
+  const db2 = getSQLiteDb();
+  const rows = db2.prepare(
+    `SELECT id, scope, subject_id, source_type, source_id, kind, title, body,
+              confidence, durability, tags, evidence, metadata, created_at, updated_at
+       FROM knowledge_entries
+       WHERE scope = ? AND subject_id = ?
+       ORDER BY updated_at DESC, created_at DESC
+       LIMIT ?`
+  ).all(input.scope, input.subjectId, input.limit ?? 50);
+  return rows.map(mapRow);
+}
+function storeKnowledgeEntries(drafts) {
+  if (drafts.length === 0) return 0;
+  const db2 = getSQLiteDb();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingStmt = db2.prepare(
+    `SELECT id
+     FROM knowledge_entries
+     WHERE scope = ? AND subject_id = ? AND content_hash = ?
+     LIMIT 1`
+  );
+  const insertStmt = db2.prepare(
+    `INSERT INTO knowledge_entries (
+      id, scope, subject_id, source_type, source_id, kind, title, body,
+      confidence, durability, tags, evidence, metadata, content_hash, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  let inserted = 0;
+  const tx = db2.transaction((entries) => {
+    for (const draft of entries) {
+      const subjectId = draft.subjectId.trim();
+      const title = draft.title.trim();
+      const body = draft.body.trim();
+      const sourceId = draft.sourceId.trim();
+      if (!subjectId || !title || !body || !sourceId) continue;
+      const contentHash = (0, import_crypto2.createHash)("sha256").update(`${draft.scope}
+${subjectId}
+${body}`).digest("hex");
+      const existing = existingStmt.get(draft.scope, subjectId, contentHash);
+      if (existing) continue;
+      insertStmt.run(
+        (0, import_crypto2.randomUUID)(),
+        draft.scope,
+        subjectId,
+        draft.sourceType,
+        sourceId,
+        draft.kind,
+        title,
+        body,
+        clampUnitNumber(draft.confidence),
+        clampUnitNumber(draft.durability),
+        JSON.stringify(normalizeTags(draft.tags)),
+        JSON.stringify(normalizeEvidence(draft.evidence)),
+        JSON.stringify(draft.metadata ?? {}),
+        contentHash,
+        now,
+        now
+      );
+      inserted += 1;
+    }
+  });
+  tx(drafts);
+  return inserted;
+}
+
+// ../agx-cloud/lib/knowledge-notes.ts
+var import_crypto3 = require("crypto");
+init_sqlite_query_adapter();
+function parseJsonObject2(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function normalizeContent(content) {
+  return content.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/\s+$/g, "")).join("\n").trim();
+}
+function mapRow2(row) {
+  return {
+    id: row.id,
+    scope: row.scope,
+    subjectId: row.subject_id,
+    content: row.content,
+    changeSummary: row.change_summary ?? null,
+    sourceType: row.source_type,
+    sourceId: row.source_id,
+    metadata: parseJsonObject2(row.metadata),
+    version: Number(row.version ?? 1),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function getKnowledgeNoteRow(scope, subjectId) {
+  const db2 = getSQLiteDb();
+  return db2.prepare(
+    `SELECT id, scope, subject_id, content, change_summary, source_type, source_id,
+              metadata, version, created_at, updated_at
+       FROM knowledge_notes
+       WHERE scope = ? AND subject_id = ?
+       LIMIT 1`
+  ).get(scope, subjectId);
+}
+function listLegacySystemStatements(scope, subjectId) {
+  const db2 = getSQLiteDb();
+  if (scope === "repo") {
+    const systemRepoRows = db2.prepare(
+      `SELECT content
+         FROM repo_knowledge
+         WHERE repo_id = ? AND producer = 'system'
+         ORDER BY created_at ASC`
+    ).all(subjectId);
+    const entryBodies2 = listKnowledgeEntries({ scope: "repo", subjectId, limit: 100 }).map((entry) => entry.body.trim());
+    return [...systemRepoRows.map((row) => row.content.trim()), ...entryBodies2].filter(Boolean);
+  }
+  if (scope === "project") {
+    const systemProjectRows = db2.prepare(
+      `SELECT content
+         FROM project_memory
+         WHERE project_id = ? AND producer = 'system'
+         ORDER BY created_at ASC`
+    ).all(subjectId);
+    const entryBodies2 = listKnowledgeEntries({ scope: "project", subjectId, limit: 100 }).map((entry) => entry.body.trim());
+    return [...systemProjectRows.map((row) => row.content.trim()), ...entryBodies2].filter(Boolean);
+  }
+  const agentRows = db2.prepare(
+    `SELECT content
+       FROM agent_memory
+       WHERE agent_id = ?
+       ORDER BY created_at ASC
+       LIMIT 100`
+  ).all(subjectId);
+  const entryBodies = listKnowledgeEntries({ scope: "agent", subjectId, limit: 100 }).map((entry) => entry.body.trim());
+  return [...agentRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
+}
+function synthesizeLegacyNoteContent(scope, subjectId) {
+  const unique = Array.from(new Set(listLegacySystemStatements(scope, subjectId)));
+  if (unique.length === 0) return "";
+  return unique.map((line) => `- ${line.replace(/^\-\s*/, "")}`).join("\n");
+}
+function ensureKnowledgeNote(scope, subjectId) {
+  const existing = getKnowledgeNoteRow(scope, subjectId);
+  if (existing) return mapRow2(existing);
+  const synthesized = synthesizeLegacyNoteContent(scope, subjectId);
+  if (!synthesized) return null;
+  const db2 = getSQLiteDb();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = (0, import_crypto3.randomUUID)();
+  db2.prepare(
+    `INSERT INTO knowledge_notes (
+      id, scope, subject_id, content, change_summary, source_type, source_id, metadata, version, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, 'task_completion', 'legacy-synthesis', ?, 1, ?, ?)`
+  ).run(
+    id,
+    scope,
+    subjectId,
+    synthesized,
+    "Initial note synthesized from existing system knowledge",
+    JSON.stringify({ synthesized_from_legacy: true }),
+    now,
+    now
+  );
+  db2.prepare(
+    `INSERT INTO knowledge_note_versions (
+      id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
+    ) VALUES (?, ?, 1, ?, ?, 'task_completion', 'legacy-synthesis', ?, ?)`
+  ).run(
+    (0, import_crypto3.randomUUID)(),
+    id,
+    synthesized,
+    "Initial note synthesized from existing system knowledge",
+    JSON.stringify({ synthesized_from_legacy: true }),
+    now
+  );
+  const created = getKnowledgeNoteRow(scope, subjectId);
+  return created ? mapRow2(created) : null;
+}
+function getKnowledgeNote(scope, subjectId) {
+  const trimmedSubjectId = subjectId.trim();
+  if (!trimmedSubjectId) return null;
+  return ensureKnowledgeNote(scope, trimmedSubjectId);
+}
+function upsertKnowledgeNote(input) {
+  const db2 = getSQLiteDb();
+  const subjectId = input.subjectId.trim();
+  const sourceId = input.sourceId.trim();
+  const content = normalizeContent(input.content);
+  const changeSummary = input.changeSummary?.trim() || null;
+  if (!subjectId || !sourceId) {
+    throw new Error("subjectId and sourceId are required");
+  }
+  const existing = ensureKnowledgeNote(input.scope, subjectId);
+  if (existing && normalizeContent(existing.content) === content) {
+    return { note: existing, changed: false };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = JSON.stringify(input.metadata ?? {});
+  if (!existing) {
+    const id = (0, import_crypto3.randomUUID)();
+    db2.prepare(
+      `INSERT INTO knowledge_notes (
+        id, scope, subject_id, content, change_summary, source_type, source_id, metadata, version, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`
+    ).run(id, input.scope, subjectId, content, changeSummary, input.sourceType, sourceId, metadata, now, now);
+    db2.prepare(
+      `INSERT INTO knowledge_note_versions (
+        id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
+      ) VALUES (?, ?, 1, ?, ?, ?, ?, ?, ?)`
+    ).run((0, import_crypto3.randomUUID)(), id, content, changeSummary, input.sourceType, sourceId, metadata, now);
+    const created = getKnowledgeNote(input.scope, subjectId);
+    if (!created) throw new Error("Failed to read created knowledge note");
+    return { note: created, changed: true };
+  }
+  const nextVersion = existing.version + 1;
+  db2.prepare(
+    `UPDATE knowledge_notes
+     SET content = ?, change_summary = ?, source_type = ?, source_id = ?, metadata = ?, version = ?, updated_at = ?
+     WHERE id = ?`
+  ).run(content, changeSummary, input.sourceType, sourceId, metadata, nextVersion, now, existing.id);
+  db2.prepare(
+    `INSERT INTO knowledge_note_versions (
+      id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run((0, import_crypto3.randomUUID)(), existing.id, nextVersion, content, changeSummary, input.sourceType, sourceId, metadata, now);
+  const updated = getKnowledgeNote(input.scope, subjectId);
+  if (!updated) throw new Error("Failed to read updated knowledge note");
+  return { note: updated, changed: true };
+}
+
+// ../agx-cloud/lib/memory-extractor.ts
 var VALID_TYPES = /* @__PURE__ */ new Set(["outcome", "decision", "pattern", "gotcha"]);
 var EXTRACTION_PROMPT = `You are a memory extractor for a task execution system.
 Given a completed task, extract 0-3 memories worth remembering for future tasks.
@@ -5120,24 +5752,28 @@ Each memory must be:
 
 Return ONLY a JSON array. Return [] if nothing worth remembering.
 Do not wrap in markdown code blocks. Just raw JSON.`;
-var PROJECT_KNOWLEDGE_PROMPT = `You are a project knowledge extractor for a task execution system.
-Given a completed or failed task, extract 0-2 concise project-scoped knowledge entries worth keeping.
-
-Each entry must be:
-{ "content": "one concise sentence" }
+var PROJECT_KNOWLEDGE_PROMPT = `You are maintaining a living project knowledge note for a task execution system.
+Given the current project note and a completed or failed task, decide whether the note should change.
 
-Only include information that is likely useful across future work in the same project:
-- workflows, conventions, recurring constraints
-- stable gotchas or environment realities
-- reusable project-specific practices
-
-Do not include:
-- repo-specific durable truths that belong in repo knowledge
-- one-off task status updates
-- vague summaries
+Return ONLY a JSON object:
+{
+  "updated_note": "full revised note in concise markdown",
+  "change_summary": "short summary of what changed",
+  "no_change": false
+}
 
-Return ONLY a JSON array. Return [] if nothing project-scoped is worth keeping.
-Do not wrap in markdown code blocks. Just raw JSON.`;
+Rules:
+- Revise the current note instead of appending isolated bullets.
+- Write like a person's living project notes, not an extracted fact list.
+- The note should help someone understand what the project is, what it does, what has been decided, and what lessons now shape future work.
+- Prefer short sections and narrative paragraphs in markdown. Bullets are fine only when they genuinely improve clarity.
+- Preserve strong existing content when still valid.
+- Merge duplicate ideas, sharpen wording, and remove stale or unsupported claims.
+- Only include project-scoped knowledge likely useful across future work in the same project.
+- Do not include repo-specific durable truths that belong in repo knowledge.
+- Avoid generic filler and avoid sounding like an audit log.
+- If nothing project-scoped changed, return {"no_change": true}.
+- Do not wrap in markdown code blocks. Just raw JSON.`;
 async function extractMemories(ctx) {
   const taskDescription = [
     `Goal: ${ctx.goal}`,
@@ -5183,18 +5819,16 @@ function parseProjectKnowledgeResponse(raw) {
   const cleaned = trimmed.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
   try {
     const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed)) return [];
-    const unique = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const entry of parsed) {
-      const content = typeof entry === "object" && entry !== null && typeof entry.content === "string" ? entry.content.trim() : "";
-      if (!content) continue;
-      if (unique.has(content)) continue;
-      unique.add(content);
-      result.push({ content });
-      if (result.length >= 2) break;
-    }
-    return result;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+    const updatedNote = typeof parsed.updated_note === "string" ? parsed.updated_note.trim() : "";
+    const noChange = Boolean(parsed.no_change);
+    if (noChange) return [];
+    if (!updatedNote) return [];
+    return [{
+      updated_note: updatedNote,
+      change_summary: typeof parsed.change_summary === "string" ? parsed.change_summary.trim() : void 0,
+      no_change: false
+    }];
   } catch {
     console.warn("[project-knowledge] Failed to parse LLM response:", cleaned.slice(0, 200));
     return [];
@@ -5235,10 +5869,26 @@ async function storeMemories(taskId, agentId, memories) {
   const now = Date.now();
   for (const mem of memories) {
     if (!VALID_TYPES_SET.has(mem.memory_type) || !mem.content?.trim()) continue;
-    const contentHash = (0, import_crypto2.createHash)("sha256").update(mem.content.trim()).digest("hex");
-    const result = stmt.run((0, import_crypto2.randomUUID)(), agentId, taskId, mem.memory_type, mem.content.trim(), contentHash, now);
+    const contentHash = (0, import_crypto4.createHash)("sha256").update(mem.content.trim()).digest("hex");
+    const result = stmt.run((0, import_crypto4.randomUUID)(), agentId, taskId, mem.memory_type, mem.content.trim(), contentHash, now);
     if (result.changes > 0) inserted++;
   }
+  if (inserted > 0) {
+    storeKnowledgeEntries(
+      memories.map((mem) => ({
+        scope: "agent",
+        subjectId: agentId,
+        sourceType: "task_completion",
+        sourceId: taskId,
+        kind: mem.memory_type,
+        title: mem.content.trim().slice(0, 80),
+        body: mem.content.trim(),
+        confidence: 0.7,
+        durability: 0.6,
+        metadata: { task_id: taskId }
+      }))
+    );
+  }
   return inserted;
 }
 async function extractAndStoreMemories(taskId, agentId, ctx) {
@@ -5259,7 +5909,7 @@ async function resolveProjectId(projectIdOrSlug) {
   const project = db2.prepare("SELECT id FROM projects WHERE slug = ? LIMIT 1").get(explicit);
   return project?.id ?? null;
 }
-async function extractProjectKnowledge(ctx) {
+async function extractProjectKnowledge(ctx, currentNote) {
   const taskDescription = [
     `Goal: ${ctx.goal}`,
     `Status: ${ctx.status}`,
@@ -5267,6 +5917,9 @@ async function extractProjectKnowledge(ctx) {
   ].filter(Boolean).join("\n");
   const prompt = `${PROJECT_KNOWLEDGE_PROMPT}
 
+Current note:
+${currentNote || "(empty)"}
+
 Task:
 ${taskDescription}`;
   let raw = "";
@@ -5287,29 +5940,23 @@ ${taskDescription}`;
 }
 async function storeProjectKnowledge(projectId, taskId, entries) {
   if (entries.length === 0) return 0;
-  const db2 = getSQLiteDb();
-  const existingContents = new Set(
-    db2.prepare("SELECT content FROM project_memory WHERE project_id = ? AND producer = 'system'").all(projectId).map((row) => row.content.trim())
-  );
-  const insert = db2.prepare(
-    `INSERT INTO project_memory (id, project_id, content, source, producer, created_at)
-     VALUES (?, ?, ?, ?, 'system', ?)`
-  );
-  let inserted = 0;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const entry of entries) {
-    const content = entry.content.trim();
-    if (!content || existingContents.has(content)) continue;
-    insert.run((0, import_crypto2.randomUUID)(), projectId, content, `task:${taskId}`, now);
-    existingContents.add(content);
-    inserted++;
-  }
-  return inserted;
+  const entry = entries[0];
+  if (!entry || !entry.updated_note?.trim()) return 0;
+  const result = upsertKnowledgeNote({
+    scope: "project",
+    subjectId: projectId,
+    content: entry.updated_note.trim(),
+    changeSummary: entry.change_summary,
+    sourceType: "task_completion",
+    sourceId: taskId,
+    metadata: { task_id: taskId }
+  });
+  return result.changed ? 1 : 0;
 }
 async function extractAndStoreProjectKnowledge(taskId, projectIdOrSlug, ctx) {
   const projectId = await resolveProjectId(projectIdOrSlug);
   if (!projectId) return;
-  const knowledge = await extractProjectKnowledge(ctx);
+  const knowledge = await extractProjectKnowledge(ctx, getKnowledgeNote("project", projectId)?.content ?? "");
   if (knowledge.length === 0) return;
   const inserted = await storeProjectKnowledge(projectId, taskId, knowledge);
   if (inserted > 0) {
@@ -5845,18 +6492,2164 @@ async function handleCancel(taskId, userId, reason) {
   await markCancelledActivity({ taskId, reason, userId });
 }
 
-// ../agx-cloud/worker/index.ts
-async function main() {
-  const requestedWorkers = Number(process.env.AGX_WORKER_COUNT) || 1;
-  assertWorkerCount(requestedWorkers);
-  console.log(`[worker] Starting SQLite worker (${requestedWorkers}/${MAX_WORKERS} max)...`);
-  const queue2 = await getQueue();
-  await queue2.work(
-    QUEUE_NAMES.TASK_PROCESS,
-    taskProcessor,
-    { batchSize: 5 }
+// ../agx-cloud/lib/stream-multiplexer.ts
+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");
+function toEntry(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspace_id,
+    threadId: row.thread_id,
+    agentId: row.agent_id,
+    pid: row.pid,
+    state: row.state,
+    sinceMessageId: row.since_message_id,
+    responseMessageId: row.response_message_id || "",
+    startedAt: row.started_at,
+    lastActivity: row.last_activity,
+    projectSlug: row.project_slug || ""
+  };
+}
+function getDb2() {
+  (0, import_fs9.mkdirSync)(HISTORY_DIR, { recursive: true });
+  const db2 = new import_better_sqlite34.default(DB_PATH2);
+  db2.pragma("journal_mode = WAL");
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS agent_processes (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      thread_id    TEXT NOT NULL DEFAULT '',
+      agent_id     TEXT NOT NULL,
+      pid          INTEGER NOT NULL DEFAULT 0,
+      state        TEXT NOT NULL DEFAULT 'spawning',
+      since_message_id TEXT NOT NULL DEFAULT '',
+      started_at   INTEGER NOT NULL,
+      last_activity INTEGER NOT NULL,
+      project_slug TEXT NOT NULL DEFAULT '',
+      UNIQUE (workspace_id, agent_id)
+    )
+  `);
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_state ON agent_processes (state)");
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_thread ON agent_processes (thread_id)");
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_workspace ON agent_processes (workspace_id)");
+  try {
+    db2.exec("ALTER TABLE agent_processes ADD COLUMN project_slug TEXT NOT NULL DEFAULT ''");
+  } catch {
+  }
+  try {
+    db2.exec("ALTER TABLE agent_processes ADD COLUMN response_message_id TEXT NOT NULL DEFAULT ''");
+  } catch {
+  }
+  return db2;
+}
+function withDb(fn) {
+  const db2 = getDb2();
+  try {
+    return fn(db2);
+  } finally {
+    db2.close();
+  }
+}
+function register(entry) {
+  return withDb((db2) => {
+    const result = db2.prepare(
+      `INSERT INTO agent_processes (workspace_id, thread_id, agent_id, pid, state, since_message_id, response_message_id, started_at, last_activity, project_slug)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(workspace_id, agent_id)
+       DO UPDATE SET
+         thread_id = excluded.thread_id,
+         pid = excluded.pid,
+         state = excluded.state,
+         since_message_id = excluded.since_message_id,
+         response_message_id = excluded.response_message_id,
+         started_at = excluded.started_at,
+         last_activity = excluded.last_activity,
+         project_slug = excluded.project_slug`
+    ).run(
+      entry.workspaceId,
+      entry.threadId,
+      entry.agentId,
+      entry.pid,
+      entry.state,
+      entry.sinceMessageId,
+      entry.responseMessageId || "",
+      entry.startedAt,
+      entry.lastActivity,
+      entry.projectSlug || ""
+    );
+    if (result.changes === 1 && result.lastInsertRowid) {
+      return Number(result.lastInsertRowid);
+    }
+    const row = db2.prepare(
+      "SELECT id FROM agent_processes WHERE workspace_id = ? AND agent_id = ?"
+    ).get(entry.workspaceId, entry.agentId);
+    return row?.id ?? 0;
+  });
+}
+function update(workspaceId, agentId, patch) {
+  const sets = [];
+  const values = [];
+  if (patch.state !== void 0) {
+    sets.push("state = ?");
+    values.push(patch.state);
+  }
+  if (patch.lastActivity !== void 0) {
+    sets.push("last_activity = ?");
+    values.push(patch.lastActivity);
+  }
+  if (patch.pid !== void 0) {
+    sets.push("pid = ?");
+    values.push(patch.pid);
+  }
+  if (sets.length === 0) return;
+  withDb(
+    (db2) => db2.prepare(
+      `UPDATE agent_processes SET ${sets.join(", ")} WHERE workspace_id = ? AND agent_id = ?`
+    ).run(...values, workspaceId, agentId)
+  );
+}
+function getByThread(threadId) {
+  return withDb((db2) => {
+    const rows = db2.prepare("SELECT * FROM agent_processes WHERE thread_id = ?").all(threadId);
+    return rows.map(toEntry);
+  });
+}
+function getByWorkspace(workspaceId) {
+  return withDb((db2) => {
+    const rows = db2.prepare("SELECT * FROM agent_processes WHERE workspace_id = ?").all(workspaceId);
+    return rows.map(toEntry);
+  });
+}
+function killEntries(entries) {
+  let killed = 0;
+  for (const entry of entries) {
+    if (entry.pid > 0) {
+      try {
+        process.kill(entry.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    killed++;
+  }
+  return killed;
+}
+function killByThread(threadId) {
+  const entries = getByThread(threadId).filter(
+    (e) => e.state === "running" || e.state === "spawning"
+  );
+  const killed = killEntries(entries);
+  if (killed > 0) {
+    withDb(
+      (db2) => db2.prepare(
+        `UPDATE agent_processes SET state = 'killed', last_activity = ?
+         WHERE thread_id = ? AND state IN ('running', 'spawning')`
+      ).run(Date.now(), threadId)
+    );
+  }
+  return killed;
+}
+function killByWorkspace(workspaceId) {
+  const entries = getByWorkspace(workspaceId).filter(
+    (e) => e.state === "running" || e.state === "spawning"
+  );
+  const killed = killEntries(entries);
+  if (killed > 0) {
+    withDb(
+      (db2) => db2.prepare(
+        `UPDATE agent_processes SET state = 'killed', last_activity = ?
+         WHERE workspace_id = ? AND state IN ('running', 'spawning')`
+      ).run(Date.now(), workspaceId)
+    );
+  }
+  return killed;
+}
+
+// ../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 LEGACY_THREAD_ID = "global";
+var REACTION_TYPES = /* @__PURE__ */ new Set([
+  "ack",
+  "working",
+  "done",
+  "clarify",
+  "blocked"
+]);
+var ALLOWED_TRANSITIONS = {
+  ack: /* @__PURE__ */ new Set(["ack", "working"]),
+  working: /* @__PURE__ */ new Set(["ack", "working", "done", "clarify", "blocked"]),
+  done: /* @__PURE__ */ new Set(["done", "ack", "working"]),
+  clarify: /* @__PURE__ */ new Set(["ack", "clarify", "working"]),
+  blocked: /* @__PURE__ */ new Set(["ack", "blocked", "working"])
+};
+var ReactionStoreError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ReactionStoreError";
+    this.status = status;
+  }
+};
+function hasSqliteObject(db2, type, name) {
+  const row = db2.prepare(`SELECT 1 FROM sqlite_master WHERE type = ? AND name = ? LIMIT 1`).get(type, name);
+  return Boolean(row);
+}
+function initializeMessageSearch(db2) {
+  const hasFtsTable = hasSqliteObject(db2, "table", "messages_fts");
+  db2.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+      content,
+      content='messages',
+      content_rowid='rowid',
+      tokenize='porter unicode61'
+    );
+  `);
+  db2.exec(`
+    CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content);
+    END;
+    CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content);
+    END;
+    CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE OF content ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.rowid, old.content);
+      INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content);
+    END;
+  `);
+  const messageCount = db2.prepare(`SELECT COUNT(*) as count FROM messages`).get().count;
+  if (messageCount === 0) return;
+  const ftsCount = db2.prepare(`SELECT COUNT(*) as count FROM messages_fts`).get().count;
+  const shouldBackfill = !hasFtsTable || ftsCount === 0;
+  if (shouldBackfill) {
+    db2.exec(`INSERT INTO messages_fts(rowid, content) SELECT rowid, content FROM messages;`);
+  }
+}
+function isThreadScopedTable(db2, tableName) {
+  const columns = db2.prepare(`PRAGMA table_info(${tableName})`).all();
+  return columns.some((column) => column.name === "thread_id");
+}
+function migrateThreadReplyColumns(db2) {
+  const columns = db2.prepare(`PRAGMA table_info(messages)`).all();
+  const colNames = new Set(columns.map((c) => c.name));
+  if (!colNames.has("root_message_id")) {
+    db2.exec(`
+      ALTER TABLE messages ADD COLUMN root_message_id TEXT;
+      ALTER TABLE messages ADD COLUMN parent_message_id TEXT;
+      ALTER TABLE messages ADD COLUMN depth INTEGER NOT NULL DEFAULT 0;
+      CREATE INDEX IF NOT EXISTS idx_messages_root ON messages(thread_id, root_message_id);
+    `);
+  }
+}
+function migrateThreadStatusColumns(db2) {
+  const columns = db2.prepare(`PRAGMA table_info(messages)`).all();
+  const colNames = new Set(columns.map((c) => c.name));
+  if (!colNames.has("thread_status")) {
+    db2.exec(`
+      ALTER TABLE messages ADD COLUMN thread_status TEXT;
+      ALTER TABLE messages ADD COLUMN outcome_note TEXT;
+    `);
+  }
+}
+function migrateReactionHostPidColumn(db2) {
+  const columns = db2.prepare(`PRAGMA table_info(message_reactions)`).all();
+  const colNames = new Set(columns.map((c) => c.name));
+  if (!colNames.has("host_pid")) {
+    db2.exec(`ALTER TABLE message_reactions ADD COLUMN host_pid INTEGER`);
+  }
+  if (!colNames.has("response_message_id")) {
+    db2.exec(`ALTER TABLE message_reactions ADD COLUMN response_message_id TEXT`);
+  }
+}
+function migrateLogsToAgentProcessId(db2) {
+  const columns = db2.prepare(`PRAGMA table_info(logs)`).all();
+  const colNames = new Set(columns.map((c) => c.name));
+  if (colNames.has("agent_process_id")) return;
+  db2.exec(`
+    DROP TABLE IF EXISTS logs;
+    CREATE TABLE logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_process_id INTEGER NOT NULL,
+      stream TEXT NOT NULL,
+      line TEXT NOT NULL,
+      timestamp INTEGER NOT NULL
+    );
+  `);
+}
+function migrateAgentProcessesAddId(db2) {
+  const columns = db2.prepare(`PRAGMA table_info(agent_processes)`).all();
+  if (columns.length === 0) return;
+  const colNames = new Set(columns.map((c) => c.name));
+  if (colNames.has("id")) return;
+  db2.exec(`
+    DROP TABLE IF EXISTS agent_processes;
+    CREATE TABLE agent_processes (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      thread_id    TEXT NOT NULL DEFAULT '',
+      agent_id     TEXT NOT NULL,
+      pid          INTEGER NOT NULL DEFAULT 0,
+      state        TEXT NOT NULL DEFAULT 'spawning',
+      since_message_id TEXT NOT NULL DEFAULT '',
+      started_at   INTEGER NOT NULL DEFAULT 0,
+      last_activity INTEGER NOT NULL DEFAULT 0,
+      project_slug TEXT NOT NULL DEFAULT '',
+      UNIQUE (workspace_id, agent_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_processes_state ON agent_processes (state);
+    CREATE INDEX IF NOT EXISTS idx_agent_processes_thread ON agent_processes (thread_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_processes_workspace ON agent_processes (workspace_id);
+  `);
+}
+function parseJsonObject3(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseJsonStringArray(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function toChatRunRecord(row) {
+  return {
+    id: row.id,
+    threadId: row.thread_id,
+    rootMessageId: row.root_message_id,
+    userId: row.user_id,
+    projectSlug: row.project_slug,
+    status: row.status,
+    currentStep: row.current_step,
+    maxSteps: row.max_steps,
+    stepsUsed: row.steps_used,
+    lastError: row.last_error,
+    activeParticipantIds: parseJsonStringArray(row.active_participant_ids),
+    payload: parseJsonObject3(row.payload_json),
+    result: parseJsonObject3(row.result_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    completedAt: row.completed_at
+  };
+}
+function toChatRunStepRecord(row) {
+  return {
+    id: row.id,
+    chatRunId: row.chat_run_id,
+    stepIndex: row.step_index,
+    kind: row.kind,
+    status: row.status,
+    participantId: row.participant_id,
+    inputPayload: parseJsonObject3(row.input_payload_json),
+    outputPayload: parseJsonObject3(row.output_payload_json),
+    startedAt: row.started_at,
+    completedAt: row.completed_at
+  };
+}
+function migrateLegacyTables(db2) {
+  if (!isThreadScopedTable(db2, "messages")) {
+    db2.exec(`
+      ALTER TABLE messages RENAME TO messages_legacy;
+      CREATE TABLE messages (
+        thread_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        participant_id TEXT,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        PRIMARY KEY (thread_id, id)
+      );
+      INSERT INTO messages (thread_id, id, role, participant_id, content, timestamp)
+      SELECT '${LEGACY_THREAD_ID}', id, role, participant_id, content, timestamp
+      FROM messages_legacy;
+      DROP TABLE messages_legacy;
+    `);
+  }
+  if (!isThreadScopedTable(db2, "message_reactions")) {
+    db2.exec(`
+      ALTER TABLE message_reactions RENAME TO message_reactions_legacy;
+      CREATE TABLE message_reactions (
+        thread_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        participant_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        reason TEXT,
+        blocker_code TEXT,
+        host_pid INTEGER,
+        response_message_id TEXT,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (thread_id, message_id, participant_id)
+      );
+      INSERT INTO message_reactions (thread_id, message_id, participant_id, type, reason, blocker_code, host_pid, updated_at)
+      SELECT '${LEGACY_THREAD_ID}', message_id, participant_id, type, reason, blocker_code, NULL, updated_at
+      FROM message_reactions_legacy;
+      DROP TABLE message_reactions_legacy;
+    `);
+  }
+  migrateLogsToAgentProcessId(db2);
+}
+var withDatabase = async (run) => {
+  await import_fs10.promises.mkdir(HISTORY_DIR2, { recursive: true });
+  const db2 = new import_better_sqlite35.default(DB_PATH3);
+  db2.pragma("journal_mode = WAL");
+  try {
+    db2.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        thread_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        participant_id TEXT,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        PRIMARY KEY (thread_id, id)
+      );
+      CREATE TABLE IF NOT EXISTS message_reactions (
+        thread_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        participant_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        reason TEXT,
+        blocker_code TEXT,
+        host_pid INTEGER,
+        response_message_id TEXT,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (thread_id, message_id, participant_id)
+      );
+      CREATE TABLE IF NOT EXISTS agent_processes (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        workspace_id TEXT NOT NULL,
+        thread_id    TEXT NOT NULL DEFAULT '',
+        agent_id     TEXT NOT NULL,
+        pid          INTEGER NOT NULL DEFAULT 0,
+        state        TEXT NOT NULL DEFAULT 'spawning',
+        since_message_id TEXT NOT NULL DEFAULT '',
+        started_at   INTEGER NOT NULL DEFAULT 0,
+        last_activity INTEGER NOT NULL DEFAULT 0,
+        project_slug TEXT NOT NULL DEFAULT '',
+        UNIQUE (workspace_id, agent_id)
+      );
+      CREATE TABLE IF NOT EXISTS logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_process_id INTEGER NOT NULL,
+        stream TEXT NOT NULL,
+        line TEXT NOT NULL,
+        timestamp INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS task_drafts (
+        thread_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (thread_id, message_id)
+      );
+      CREATE TABLE IF NOT EXISTS chat_runs (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        root_message_id TEXT,
+        user_id TEXT NOT NULL,
+        project_slug TEXT,
+        status TEXT NOT NULL,
+        current_step INTEGER NOT NULL DEFAULT 0,
+        max_steps INTEGER NOT NULL DEFAULT 10,
+        steps_used INTEGER NOT NULL DEFAULT 0,
+        last_error TEXT,
+        active_participant_ids TEXT NOT NULL DEFAULT '[]',
+        payload_json TEXT,
+        result_json TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS chat_run_steps (
+        id TEXT PRIMARY KEY,
+        chat_run_id TEXT NOT NULL,
+        step_index INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        participant_id TEXT,
+        input_payload_json TEXT,
+        output_payload_json TEXT,
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER
+      );
+    `);
+    migrateLegacyTables(db2);
+    migrateThreadReplyColumns(db2);
+    migrateThreadStatusColumns(db2);
+    migrateReactionHostPidColumn(db2);
+    db2.exec("UPDATE messages SET thread_status = 'in-review' WHERE thread_status = 'parked'");
+    db2.exec("UPDATE messages SET thread_status = 'active' WHERE thread_status = 'thinking'");
+    db2.exec("UPDATE messages SET thread_status = 'done' WHERE thread_status = 'resolved'");
+    db2.exec("UPDATE messages SET thread_status = 'active' WHERE thread_status = 'converged'");
+    migrateAgentProcessesAddId(db2);
+    initializeMessageSearch(db2);
+    db2.exec(`
+      CREATE INDEX IF NOT EXISTS idx_messages_thread_ts ON messages(thread_id, timestamp ASC);
+      CREATE INDEX IF NOT EXISTS idx_reactions_thread_message ON message_reactions(thread_id, message_id, updated_at ASC);
+      CREATE INDEX IF NOT EXISTS idx_logs_process_ts ON logs(agent_process_id, timestamp ASC);
+      CREATE INDEX IF NOT EXISTS idx_chat_runs_thread_updated ON chat_runs(thread_id, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_chat_runs_status_updated ON chat_runs(status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_chat_run_steps_run_step ON chat_run_steps(chat_run_id, step_index ASC);
+    `);
+    return run(db2);
+  } finally {
+    db2.close();
+  }
+};
+function aggregateReactionRows(rows) {
+  const perMessage = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let byType = perMessage.get(row.message_id);
+    if (!byType) {
+      byType = /* @__PURE__ */ new Map();
+      perMessage.set(row.message_id, byType);
+    }
+    let reaction = byType.get(row.type);
+    if (!reaction) {
+      reaction = { type: row.type, count: 0, participantIds: [] };
+      byType.set(row.type, reaction);
+    }
+    reaction.count += 1;
+    reaction.participantIds.push(row.participant_id);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [messageId, byType] of perMessage.entries()) {
+    const sorted = Array.from(byType.values()).sort((a, b) => {
+      if (b.count !== a.count) return b.count - a.count;
+      return a.type.localeCompare(b.type);
+    });
+    out.set(messageId, sorted);
+  }
+  return out;
+}
+function loadMessageReactions(db2, threadId, messageIds) {
+  if (messageIds && messageIds.length === 0) return /* @__PURE__ */ new Map();
+  if (messageIds) {
+    const placeholders = messageIds.map(() => "?").join(", ");
+    const rows2 = db2.prepare(
+      `SELECT message_id, participant_id, type
+         FROM message_reactions
+         WHERE thread_id = ? AND message_id IN (${placeholders})
+         ORDER BY updated_at ASC`
+    ).all(threadId, ...messageIds);
+    return aggregateReactionRows(rows2);
+  }
+  const rows = db2.prepare(
+    `SELECT message_id, participant_id, type
+       FROM message_reactions
+       WHERE thread_id = ?
+       ORDER BY updated_at ASC`
+  ).all(threadId);
+  return aggregateReactionRows(rows);
+}
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeOptionalHostPid(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
+  return value;
+}
+function isAllowedTransition(from, to) {
+  if (!from) return true;
+  return ALLOWED_TRANSITIONS[from].has(to);
+}
+async function saveMessages(threadId, messages) {
+  if (messages.length === 0) return;
+  const normalizedThreadId = threadId.trim() || LEGACY_THREAD_ID;
+  await withDatabase((db2) => {
+    const stmt = db2.prepare(
+      `INSERT OR REPLACE INTO messages (thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insertMany = db2.transaction((msgs) => {
+      for (const m of msgs) {
+        stmt.run(normalizedThreadId, m.id, m.role, m.participantId, m.content, m.timestamp, m.rootMessageId ?? null, m.parentMessageId ?? null, m.depth ?? 0, m.threadStatus ?? null, m.outcomeNote ?? null);
+      }
+    });
+    insertMany(messages);
+  });
+}
+async function getChatRun(chatRunId) {
+  return withDatabase((db2) => {
+    const row = db2.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(chatRunId);
+    return row ? toChatRunRecord(row) : null;
+  });
+}
+async function updateChatRun(input) {
+  return withDatabase((db2) => {
+    const updates = ["updated_at = ?"];
+    const params = [Date.now()];
+    if (input.status) {
+      updates.push("status = ?");
+      params.push(input.status);
+    }
+    if (typeof input.currentStep === "number") {
+      updates.push("current_step = ?");
+      params.push(input.currentStep);
+    }
+    if (typeof input.stepsUsed === "number") {
+      updates.push("steps_used = ?");
+      params.push(input.stepsUsed);
+    }
+    if (input.lastError !== void 0) {
+      updates.push("last_error = ?");
+      params.push(normalizeOptionalText(input.lastError));
+    }
+    if (input.payload !== void 0) {
+      updates.push("payload_json = ?");
+      params.push(input.payload ? JSON.stringify(input.payload) : null);
+    }
+    if (input.result !== void 0) {
+      updates.push("result_json = ?");
+      params.push(input.result ? JSON.stringify(input.result) : null);
+    }
+    if (input.completedAt !== void 0) {
+      updates.push("completed_at = ?");
+      params.push(input.completedAt);
+    }
+    params.push(input.id);
+    db2.prepare(`UPDATE chat_runs SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+    const row = db2.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(input.id);
+    return row ? toChatRunRecord(row) : null;
+  });
+}
+async function appendChatRunStep(input) {
+  const now = Date.now();
+  return withDatabase((db2) => {
+    db2.prepare(
+      `INSERT INTO chat_run_steps (
+        id, chat_run_id, step_index, kind, status, participant_id,
+        input_payload_json, output_payload_json, started_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.id,
+      input.chatRunId,
+      input.stepIndex,
+      input.kind,
+      input.status,
+      normalizeOptionalText(input.participantId),
+      input.inputPayload ? JSON.stringify(input.inputPayload) : null,
+      input.outputPayload ? JSON.stringify(input.outputPayload) : null,
+      now,
+      input.status === "completed" || input.status === "failed" ? now : null
+    );
+    const row = db2.prepare("SELECT * FROM chat_run_steps WHERE id = ? LIMIT 1").get(input.id);
+    if (!row) {
+      throw new Error(`Failed to append chat run step ${input.id}`);
+    }
+    return toChatRunStepRecord(row);
+  });
+}
+async function updateChatRunStep(input) {
+  return withDatabase((db2) => {
+    const updates = [];
+    const params = [];
+    if (input.status) {
+      updates.push("status = ?");
+      params.push(input.status);
+    }
+    if (input.outputPayload !== void 0) {
+      updates.push("output_payload_json = ?");
+      params.push(input.outputPayload ? JSON.stringify(input.outputPayload) : null);
+    }
+    if (input.completedAt !== void 0) {
+      updates.push("completed_at = ?");
+      params.push(input.completedAt);
+    }
+    if (updates.length === 0) {
+      const existing = db2.prepare("SELECT * FROM chat_run_steps WHERE id = ? LIMIT 1").get(input.id);
+      return existing ? toChatRunStepRecord(existing) : null;
+    }
+    params.push(input.id);
+    db2.prepare(`UPDATE chat_run_steps SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+    const row = db2.prepare("SELECT * FROM chat_run_steps WHERE id = ? LIMIT 1").get(input.id);
+    return row ? toChatRunStepRecord(row) : null;
+  });
+}
+async function listChatRunSteps(chatRunId) {
+  return withDatabase((db2) => {
+    const rows = db2.prepare("SELECT * FROM chat_run_steps WHERE chat_run_id = ? ORDER BY step_index ASC, started_at ASC").all(chatRunId);
+    return rows.map(toChatRunStepRecord);
+  });
+}
+async function setReaction(input) {
+  const threadId = input.threadId?.trim() || LEGACY_THREAD_ID;
+  const messageId = input.messageId?.trim();
+  const participantId = input.participantId?.trim();
+  const type = input.type;
+  if (!messageId) {
+    throw new ReactionStoreError("messageId is required", 400);
+  }
+  if (!participantId) {
+    throw new ReactionStoreError("participantId is required", 400);
+  }
+  if (!REACTION_TYPES.has(type)) {
+    throw new ReactionStoreError(`Invalid reaction type: ${String(type)}`, 400);
+  }
+  const incomingReason = normalizeOptionalText(input.reason);
+  const incomingBlockerCode = normalizeOptionalText(input.blockerCode);
+  const hostPid = normalizeOptionalHostPid(input.hostPid);
+  const responseMessageId = normalizeOptionalText(input.responseMessageId);
+  const needsReason = type === "clarify" || type === "blocked";
+  if (needsReason && !incomingReason) {
+    throw new ReactionStoreError(`"${type}" reactions require a reason`, 400);
+  }
+  const reason = needsReason ? incomingReason : null;
+  const blockerCode = type === "blocked" ? incomingBlockerCode : null;
+  return withDatabase((db2) => {
+    const messageExists = db2.prepare(`SELECT 1 FROM messages WHERE thread_id = ? AND id = ? LIMIT 1`).get(threadId, messageId);
+    if (!messageExists) {
+      throw new ReactionStoreError(`Message not found: ${messageId}`, 404);
+    }
+    const existing = db2.prepare(
+      `SELECT type, reason, blocker_code, host_pid
+         FROM message_reactions
+         WHERE thread_id = ? AND message_id = ? AND participant_id = ?`
+    ).get(threadId, messageId, participantId);
+    if (!isAllowedTransition(existing?.type ?? null, type)) {
+      throw new ReactionStoreError(
+        `Cannot transition reaction from "${existing.type}" to "${type}"`,
+        409
+      );
+    }
+    const unchanged = existing && existing.type === type && normalizeOptionalText(existing.reason) === reason && normalizeOptionalText(existing.blocker_code) === blockerCode && normalizeOptionalHostPid(existing.host_pid) === hostPid;
+    if (unchanged) {
+      return {
+        updated: false,
+        reactions: loadMessageReactions(db2, threadId, [messageId]).get(messageId) ?? []
+      };
+    }
+    const now = Date.now();
+    db2.prepare(
+      `INSERT INTO message_reactions (thread_id, message_id, participant_id, type, reason, blocker_code, host_pid, response_message_id, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(thread_id, message_id, participant_id)
+       DO UPDATE SET
+         type = excluded.type,
+         reason = excluded.reason,
+         blocker_code = excluded.blocker_code,
+         host_pid = excluded.host_pid,
+         response_message_id = COALESCE(excluded.response_message_id, message_reactions.response_message_id),
+         updated_at = excluded.updated_at`
+    ).run(threadId, messageId, participantId, type, reason, blockerCode, hostPid, responseMessageId, now);
+    return {
+      updated: true,
+      reactions: loadMessageReactions(db2, threadId, [messageId]).get(messageId) ?? []
+    };
+  });
+}
+async function saveLogs(agentProcessId, entries) {
+  if (entries.length === 0 || !agentProcessId) return;
+  return withDatabase((db2) => {
+    const stmt = db2.prepare(
+      "INSERT INTO logs (agent_process_id, stream, line, timestamp) VALUES (?, ?, ?, ?)"
+    );
+    const tx = db2.transaction(() => {
+      for (const e of entries) {
+        stmt.run(agentProcessId, e.stream, e.line, e.timestamp);
+      }
+    });
+    tx();
+  });
+}
+
+// ../agx-cloud/lib/reaction-protocol.ts
+var REACTION_TYPES2 = /* @__PURE__ */ new Set([
+  "ack",
+  "working",
+  "done",
+  "clarify",
+  "blocked"
+]);
+var TAG_REGEX = /\[reaction\s+([^\]]+)\]/gi;
+var ATTR_REGEX = /([a-zA-Z][a-zA-Z0-9_]*)=(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|([^\s\]]*?(?=\s|]|[a-zA-Z][a-zA-Z0-9_]*=|$)))/g;
+function decodeAttrValue(value) {
+  return value.replace(/\\(["'\\])/g, "$1").trim();
+}
+function parseAttributes(raw) {
+  const attrs = /* @__PURE__ */ new Map();
+  ATTR_REGEX.lastIndex = 0;
+  for (; ; ) {
+    const match = ATTR_REGEX.exec(raw);
+    if (!match) break;
+    const key = match[1].toLowerCase();
+    const quotedDouble = match[2];
+    const quotedSingle = match[3];
+    const bare = match[4];
+    const value = decodeAttrValue(quotedDouble ?? quotedSingle ?? bare ?? "");
+    attrs.set(key, value);
+  }
+  return attrs;
+}
+function parseReactionSignals(content) {
+  const signals = [];
+  const invalid = [];
+  const cleanedText = content.replace(TAG_REGEX, (rawTag, attrsRaw) => {
+    const attrs = parseAttributes(String(attrsRaw));
+    const target = (attrs.get("target") || "").trim();
+    const typeRaw = (attrs.get("type") || "").trim().toLowerCase();
+    const reason = (attrs.get("reason") || "").trim();
+    const blockerCode = (attrs.get("blockercode") || attrs.get("blocker_code") || "").trim();
+    if (!target) {
+      invalid.push({ raw: rawTag, error: "Missing target" });
+      return "";
+    }
+    if (!REACTION_TYPES2.has(typeRaw)) {
+      invalid.push({ raw: rawTag, error: `Invalid type: ${typeRaw || "(empty)"}` });
+      return "";
+    }
+    const type = typeRaw;
+    if ((type === "clarify" || type === "blocked") && !reason) {
+      invalid.push({ raw: rawTag, error: `"${type}" requires reason` });
+      return "";
+    }
+    signals.push({
+      raw: rawTag,
+      target,
+      type,
+      reason: reason || void 0,
+      blockerCode: type === "blocked" ? blockerCode || void 0 : void 0
+    });
+    return "";
+  }).replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return { signals, invalid, cleanedText };
+}
+
+// ../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");
+function getDb3() {
+  const db2 = new import_better_sqlite36.default(DB_PATH4);
+  db2.pragma("journal_mode = WAL");
+  return db2;
+}
+function initAttachmentsTable(db2) {
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS attachments (
+      id TEXT PRIMARY KEY,
+      message_id TEXT,
+      filename TEXT NOT NULL,
+      disk_name TEXT NOT NULL,
+      mime_type TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'uploaded',
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_attachments_message ON attachments(message_id);
+  `);
+  const cols = db2.prepare("PRAGMA table_info(attachments)").all();
+  if (!cols.some((c) => c.name === "disk_name")) {
+    db2.exec(`ALTER TABLE attachments ADD COLUMN disk_name TEXT NOT NULL DEFAULT ''`);
+    const rows = db2.prepare("SELECT id, filename FROM attachments WHERE disk_name = ''").all();
+    const stmt = db2.prepare("UPDATE attachments SET disk_name = ? WHERE id = ?");
+    for (const r of rows) {
+      const ext = r.filename.includes(".") ? "." + r.filename.split(".").pop().toLowerCase() : "";
+      stmt.run(r.id + ext, r.id);
+    }
+  }
+}
+async function getAttachmentMeta(id) {
+  const db2 = getDb3();
+  try {
+    initAttachmentsTable(db2);
+    const row = db2.prepare(
+      `SELECT filename, disk_name, mime_type, size FROM attachments WHERE 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) };
+  } finally {
+    db2.close();
+  }
+}
+
+// ../agx-cloud/lib/stream-multiplexer.ts
+init_sqlite_query_adapter();
+init_self();
+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");
+init_journal();
+init_activity();
+var AGENTS_DIR6 = (0, import_path12.join)((0, import_os12.homedir)(), ".agx", "agents");
+function reactionsPath(agentId) {
+  return (0, import_path12.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 });
+}
+function targetEntryExists(targetEntry) {
+  const [targetAgent] = targetEntry.split(":");
+  if (!targetAgent) return false;
+  const entries = readJournal(targetAgent);
+  return entries.some((e) => e.id === targetEntry);
+}
+function appendReaction(agentId, targetEntry, type) {
+  if (!targetEntryExists(targetEntry)) {
+    throw new Error(`Target entry ${targetEntry} not found`);
+  }
+  ensureDir2(agentId);
+  const reaction = {
+    agent: agentId,
+    t: (/* @__PURE__ */ new Date()).toISOString(),
+    targetEntry,
+    type
+  };
+  (0, import_fs11.appendFileSync)(reactionsPath(agentId), JSON.stringify(reaction) + "\n", "utf-8");
+  logActivity(agentId, "mesh-reaction", { meta: { target: targetEntry, type } });
+}
+
+// ../agx-cloud/lib/stream-multiplexer.ts
+init_activity();
+var import_crypto5 = require("crypto");
+var agentMessageCounts = /* @__PURE__ */ new Map();
+var reflectionQueues = /* @__PURE__ */ new Map();
+var REFLECTION_CADENCE = 10;
+function isKnowledgeEvidence(value) {
+  return value !== null;
+}
+function seedFromIdentityText(identity, name) {
+  const raw = String(identity || "").trim();
+  if (!raw) return `I am ${name}. I evolve through experience and collaboration.`;
+  return `I am ${name}. I evolve through experience and collaboration.`;
+}
+function derivePerMessageJournalInsights(response) {
+  const text = response.trim();
+  const preview = text.slice(0, 120).replace(/\n/g, " ");
+  const hasQuestion = /\?/.test(text);
+  const mentions = text.match(/@\w+/g) || [];
+  const hasAction = /\b(should|need to|must|plan|steps?|implement|fix|verify|ship|next|start)\b/i.test(text);
+  const hasUncertainty = /\b(maybe|might|could|unsure|not sure|unclear)\b/i.test(text);
+  const hasCommitment = /\b(i will|i'll|i can|i'm going to|starting|checking|verified|fixed|done|shipped)\b/i.test(text);
+  const hasCode = /```/.test(text) || /\bfunction\b|\bconst\b|\binterface\b/i.test(text);
+  const hasSpec = /\|.*\|.*\|/.test(text) || /^#{1,3}\s/m.test(text);
+  const hasReview = /\b(finding|issue|bug|problem|missing|broken|wrong)\b/i.test(text);
+  let judgement;
+  if (hasCode && hasSpec) {
+    judgement = `Observed a structured technical response with code or implementation detail \u2014 "${preview}..."`;
+  } else if (hasCode) {
+    judgement = `Observed code-centric output \u2014 "${preview}..."`;
+  } else if (hasSpec) {
+    judgement = `Observed structured analysis or specification language \u2014 "${preview}..."`;
+  } else if (hasReview) {
+    judgement = `Observed review or issue-spotting behavior \u2014 "${preview}..."`;
+  } else if (hasCommitment) {
+    judgement = `Observed a concrete commitment to action \u2014 "${preview}..."`;
+  } else if (hasAction) {
+    judgement = `Observed direction-setting or next-step guidance \u2014 "${preview}..."`;
+  } else if (hasQuestion) {
+    judgement = `Observed clarifying or exploratory questioning \u2014 "${preview}..."`;
+  } else if (hasUncertainty) {
+    judgement = `Observed explicit uncertainty or caveating \u2014 "${preview}..."`;
+  } else if (mentions.length > 0) {
+    judgement = `Observed coordination with ${mentions.join(", ")} \u2014 "${preview}..."`;
+  } else {
+    judgement = `Observed a general perspective contribution \u2014 "${preview}..."`;
+  }
+  const signals = [];
+  if (hasCode || hasSpec) signals.push("technical depth");
+  if (hasAction || hasCommitment) signals.push("execution bias");
+  if (hasQuestion) signals.push("inquiry instinct");
+  if (hasReview) signals.push("critical eye");
+  if (mentions.length > 0) signals.push("team coordination");
+  if (hasUncertainty) signals.push("intellectual honesty");
+  let delta;
+  if (signals.length > 0) {
+    delta = `Candidate specialization signals: ${signals.join(" + ")}. Treat as suggestive evidence, not settled identity.`;
+  } else {
+    delta = `Low-signal contribution for specialization; keep as weak evidence only.`;
+  }
+  let intent;
+  if (hasAction || hasCommitment) {
+    intent = "Follow through on the action I just committed to.";
+  } else if (hasReview) {
+    intent = "Verify the issues I flagged get addressed.";
+  } else if (hasQuestion) {
+    intent = "Wait for the answer before moving forward.";
+  }
+  return { judgement, delta, intent };
+}
+function ensureAgentArtifacts(p, identityText) {
+  ensureAgent(p.id, {
+    voice: `${p.name} style`,
+    seed: seedFromIdentityText(identityText, p.name)
+  });
+}
+function enqueueReflection(p) {
+  const previous = reflectionQueues.get(p.id) ?? Promise.resolve();
+  const next = previous.catch(() => {
+  }).then(() => runReflection(p));
+  reflectionQueues.set(p.id, next);
+  return next.finally(() => {
+    if (reflectionQueues.get(p.id) === next) {
+      reflectionQueues.delete(p.id);
+    }
+  });
+}
+async function runReflection(p) {
+  ensureAgentArtifacts(p);
+  const identity = readIdentity(p.id);
+  if (!identity) return;
+  const currentSelf = readSelf(p.id);
+  const reflectionState = readReflectionState(p.id);
+  const recentEntries = readJournalSince(p.id, reflectionState?.lastProcessedJournalId).filter((entry) => entry.type === "post");
+  if (recentEntries.length === 0) return;
+  const teamSelves = getTeamSelves(p.id);
+  const newVersion = (currentSelf?.version ?? 0) + 1;
+  const existingMemories = listKnowledgeEntries({ scope: "agent", subjectId: p.id, limit: 50 });
+  const reflectionPrompt = buildStructuredReflectionPrompt(
+    identity,
+    currentSelf,
+    recentEntries,
+    teamSelves,
+    existingMemories
+  );
+  let reflectionRaw = "";
+  await runCliResponse({
+    provider: p.provider,
+    model: p.model,
+    systemContext: `You are performing a self-modeling exercise. Output ONLY raw JSON matching the requested schema. No markdown fences, no commentary.`,
+    prompt: reflectionPrompt,
+    signal: void 0,
+    onDelta: (chunk) => {
+      reflectionRaw += chunk;
+    }
+  });
+  const cleaned = reflectionRaw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    parsed = null;
+  }
+  const newSelfContent = parsed?.self_model?.trim() || "";
+  if (!newSelfContent) return;
+  const memoryDrafts = Array.isArray(parsed?.memories) ? parsed.memories.slice(0, 3).map((memory) => ({
+    scope: "agent",
+    subjectId: p.id,
+    sourceType: "reflection",
+    sourceId: recentEntries[recentEntries.length - 1]?.id || `reflection:${p.id}:${newVersion}`,
+    kind: memory.kind,
+    title: String(memory.title ?? "").trim(),
+    body: String(memory.body ?? "").trim(),
+    confidence: memory.confidence,
+    durability: memory.durability,
+    tags: memory.tags,
+    evidence: Array.isArray(memory.evidence) ? memory.evidence.map((item) => {
+      const note = String(item?.note ?? "").trim();
+      const id = typeof item?.id === "string" ? item.id.trim() : "";
+      return note ? id ? { id, note } : { note } : null;
+    }).filter(isKnowledgeEvidence) : [],
+    metadata: {
+      reflection_window_start: recentEntries[0]?.id ?? null,
+      reflection_window_end: recentEntries[recentEntries.length - 1]?.id ?? null,
+      self_version: newVersion
+    }
+  })).filter((memory) => memory.title && memory.body) : [];
+  const insertedKnowledge = storeKnowledgeEntries(memoryDrafts);
+  writeSelf(p.id, newSelfContent, newVersion);
+  writeReflectionState(p.id, {
+    lastProcessedJournalId: recentEntries[recentEntries.length - 1]?.id ?? reflectionState?.lastProcessedJournalId ?? null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (insertedKnowledge > 0) {
+    const db2 = getSQLiteDb();
+    const stmt = db2.prepare(
+      `INSERT OR IGNORE INTO agent_memory (id, agent_id, task_id, memory_type, content, content_hash, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    const reflectionTaskId = `reflection:${p.id}:${recentEntries[recentEntries.length - 1]?.id ?? newVersion}`;
+    const now = Date.now();
+    for (const memory of memoryDrafts) {
+      const memoryType = memory.kind === "decision" ? "decision" : memory.kind === "gotcha" || memory.kind === "constraint" ? "gotcha" : memory.kind === "outcome" ? "outcome" : "pattern";
+      const contentHash = (0, import_crypto5.createHash)("sha256").update(memory.body.trim()).digest("hex");
+      stmt.run((0, import_crypto5.randomUUID)(), p.id, reflectionTaskId, memoryType, memory.body.trim(), contentHash, now);
+    }
+  }
+  appendJournal(p.id, {
+    t: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "reflection",
+    observation: `Reflected after ${REFLECTION_CADENCE} messages`,
+    judgement: "Updated self-model from incremental journal evidence and deduped agent memories",
+    delta: `self-model updated to v${newVersion}${insertedKnowledge > 0 ? `; stored ${insertedKnowledge} agent memories` : ""}`,
+    threads: [],
+    selfVersion: newVersion,
+    body: newSelfContent
+  });
+  const otherAgents = listAgents().filter((id) => id !== p.id);
+  const otherEntries = otherAgents.flatMap(
+    (id) => readJournal(id, 3).map((e) => ({ agentId: id, entry: e }))
+  );
+  if (otherEntries.length > 0) {
+    const entrySummaries = otherEntries.map((o) => `${o.entry.id}: ${o.entry.observation.slice(0, 200)}`).join("\n");
+    let reactionsRaw = "";
+    try {
+      await runCliResponse({
+        provider: p.provider,
+        model: p.model,
+        prompt: `You are ${p.id}. Review these recent entries from other agents and react to any that resonate with you.
+
+Entries:
+${entrySummaries}
+
+For each entry you want to react to, output one line in this exact format:
+REACT <entryId> <type>
+
+Valid types: agree, disagree, learned-from, builds-on, curious
+
+Only react to entries that genuinely resonate. It's fine to react to zero entries. Output nothing else.`,
+        signal: void 0,
+        onDelta: (chunk) => {
+          reactionsRaw += chunk;
+        }
+      });
+    } catch {
+    }
+    for (const line of reactionsRaw.split("\n")) {
+      const match = line.trim().match(/^REACT\s+(\S+)\s+(agree|disagree|learned-from|builds-on|curious)$/);
+      if (match) {
+        try {
+          appendReaction(p.id, match[1], match[2]);
+        } catch {
+        }
+      }
+    }
+  }
+}
+async function readFileContent(filePath) {
+  try {
+    return await (0, import_promises.readFile)(filePath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `[Error reading ${filePath}: ${msg}]`;
+  }
+}
+function extractAttachmentId(reference) {
+  const trimmed = reference.trim();
+  if (!trimmed) return null;
+  const prefixedMatch = trimmed.match(/^attachment:([a-zA-Z0-9-]+)$/);
+  if (prefixedMatch) return prefixedMatch[1];
+  const apiMatch = trimmed.match(/\/api\/attachments\/([a-zA-Z0-9-]+)/);
+  if (apiMatch) return apiMatch[1];
+  const uuidMatch = trimmed.match(
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+  );
+  if (uuidMatch) return trimmed;
+  return null;
+}
+async function readReferenceContent(reference) {
+  const trimmed = reference.trim();
+  if (!trimmed) {
+    return { label: "unknown", content: "[Empty file reference]" };
+  }
+  const attachmentId = extractAttachmentId(trimmed);
+  if (attachmentId) {
+    const attachmentMeta = await getAttachmentMeta(attachmentId);
+    if (attachmentMeta) {
+      const content = await readFileContent(attachmentMeta.diskPath);
+      return { label: attachmentMeta.filename, content };
+    }
+  }
+  return { label: trimmed, content: await readFileContent(trimmed) };
+}
+function sseEncode(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+var SKIP_SIGNAL = "[SKIP]";
+var DEFAULT_MAX_ROUNDS = 10;
+var SIMILARITY_THRESHOLD = 0.5;
+function similarity(a, b) {
+  const wordsA = new Set(a.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter(Boolean));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) if (wordsB.has(w)) intersection++;
+  return intersection / (wordsA.size + wordsB.size - intersection);
+}
+function findMentions(text, all) {
+  const ids = /* @__PURE__ */ new Set();
+  const parallel = /* @__PURE__ */ new Set();
+  const lower = text.toLowerCase();
+  const hasParallelAll = lower.includes("@@all");
+  const hasPlainAll = lower.includes("@all");
+  if (hasPlainAll || hasParallelAll) {
+    for (const p of all) {
+      ids.add(p.id);
+      if (hasParallelAll) parallel.add(p.id);
+    }
+    return { ids, parallel };
+  }
+  try {
+    const db2 = getSQLiteDb();
+    const projects = db2.prepare("SELECT id, name, slug FROM projects").all();
+    for (const project of projects) {
+      const projectNameLower = project.name.toLowerCase();
+      const projectSlugLower = project.slug.toLowerCase();
+      const hasParallelProject = lower.includes(`@@${projectNameLower}`) || lower.includes(`@@${projectSlugLower}`);
+      const hasProject = lower.includes(`@${projectNameLower}`) || lower.includes(`@${projectSlugLower}`);
+      if (hasParallelProject || hasProject) {
+        const members = db2.prepare("SELECT agent_id FROM project_agents WHERE project_id = ? ORDER BY routing_order ASC").all(project.id);
+        for (const m of members) {
+          ids.add(m.agent_id);
+          if (hasParallelProject) parallel.add(m.agent_id);
+        }
+      }
+    }
+  } catch {
+  }
+  for (const p of all) {
+    const idLower = p.id.toLowerCase();
+    const nameLower = p.name.toLowerCase();
+    const hasParallelId = lower.includes(`@@${idLower}`);
+    const hasParallelName = lower.includes(`@@${nameLower}`);
+    const hasPlainId = lower.includes(`@${idLower}`);
+    const hasPlainName = lower.includes(`@${nameLower}`);
+    if (hasParallelId || hasParallelName || hasPlainId || hasPlainName) {
+      ids.add(p.id);
+      if (hasParallelId || hasParallelName) {
+        parallel.add(p.id);
+      }
+    }
+  }
+  return { ids, parallel };
+}
+function cleanParallelMentions(text, all) {
+  let cleaned = text;
+  cleaned = cleaned.replace(/@@all/gi, "@all");
+  for (const p of all) {
+    cleaned = cleaned.replace(new RegExp(`@@${p.name}`, "gi"), `@${p.name}`);
+    cleaned = cleaned.replace(new RegExp(`@@${p.id}`, "gi"), `@${p.id}`);
+  }
+  return cleaned;
+}
+function resolveRuntimeSkills(participant, projectContext) {
+  const fromProvenance = projectContext?.provenanceByAgentId?.[participant.id]?.skills;
+  if (fromProvenance && fromProvenance.length > 0) {
+    return fromProvenance;
+  }
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const skill of participant.skills ?? []) {
+    const basename = skill.file.split("/").pop() || skill.file;
+    if (seen.has(basename)) continue;
+    seen.add(basename);
+    resolved.push({ file: skill.file, condition: skill.condition, source: "agent" });
+  }
+  for (const skill of projectContext?.skills ?? []) {
+    const basename = skill.file.split("/").pop() || skill.file;
+    if (seen.has(basename)) continue;
+    seen.add(basename);
+    resolved.push({ file: skill.file, condition: skill.condition, source: "project" });
+  }
+  return resolved;
+}
+function buildContext(self, all, active, transcript, recentHistory, exchangeMessages, currentUserMessageId, projectContext) {
+  const otherActive = active.filter((p) => p.id !== self.id);
+  const otherNames = otherActive.map((p) => p.name).join(", ");
+  const allNames = all.map((p) => p.name).join(", ");
+  const exampleName = all.find((p) => p.id !== self.id)?.name || "Name";
+  let context = `<role>
+You are "${self.name}" in a group chat. All agents: ${allNames}.`;
+  if (otherNames) {
+    context += ` Currently active in this exchange: ${otherNames}.`;
+  }
+  context += `
+Respond as ${self.name} only. Keep responses conversational and concise.
+IMPORTANT: Always respond to the user's actual question. Do not reference unrelated technical context, previous threads, or system internals unless directly asked.
+</role>`;
+  context += `
+
+<protocol>
+Mentions:
+- Invite other agents by @mentioning them (e.g. @${exampleName}). By default they respond one at a time.
+- To run agents in parallel, use @@ (double-at): @@${exampleName} \u2014 e.g. "@@Alice @@Bob" runs both concurrently.
+- You only get another turn if someone else @mentions you.
+- Do NOT @mention yourself. Never include @${self.name} in your response.
+- If your work is complete, just deliver your final response.
+
+Reactions (machine-readable status channel):
+- Emit status with tags: [reaction target=<messageId> type=ack|working|done|clarify|blocked reason="..." blockerCode=<optional>]
+- Use ack when seen/no action needed, working when you start, done when complete.
+- Use clarify when missing information and blocked when a hard dependency fails.
+- clarify and blocked REQUIRE reason="...". blocked may also include blockerCode=<code>.
+- Prefer targeting the current user message unless you are explicitly reacting to a different message.`;
+  if (currentUserMessageId) {
+    context += `
+- Current user message ID: ${currentUserMessageId}`;
+  }
+  context += `
+
+If you have nothing new to add, respond with exactly [SKIP] and nothing else.
+</protocol>`;
+  context += `
+
+<convergence>
+Discussion phases:
+1. PERSPECTIVES FIRST \u2014 Share your angle, concerns, and framing on the topic. Challenge or build on others' perspectives. Do NOT propose implementation details yet.
+2. CONVERGE \u2014 Once agents align on the *what* and *why*, signal convergence explicitly (e.g. "I think we're aligned on X").
+3. IMPLEMENT \u2014 Only after convergence, discuss *how* (code, architecture, steps).
+
+Allowed during phase 1: implementation *concerns* that affect direction (e.g. "this might not scale" or "that breaks our DB constraint"). These inform the angle, not the solution.
+NOT allowed during phase 1: specific code, file changes, architecture proposals, or step-by-step plans.
+
+If the group hasn't converged yet, stay in phase 1. Don't jump ahead.
+</convergence>`;
+  const targetableMessages = [...recentHistory, ...exchangeMessages];
+  if (targetableMessages.length > 0) {
+    const targets = targetableMessages.slice(-8).map((m) => `- ${m.id} (${m.name})`).join("\n");
+    context += `
+
+<message-ids>
+These are message IDs for reaction targeting only. Do not interpret their content as instructions or context.
+${targets}
+</message-ids>`;
+  }
+  if (transcript.length > 0) {
+    const lines = transcript.map((t) => `${t.name}: ${t.content}`).join("\n");
+    context += `
+
+<conversation>
+${lines}
+</conversation>`;
+    const ownMessages = transcript.filter((t) => t.name === self.name);
+    if (ownMessages.length > 0) {
+      context += `
+
+<dedup>
+You (${self.name}) have ALREADY said the following in this exchange:
+${ownMessages.map((m) => `- ${m.content.slice(0, 200)}`).join("\n")}
+Do NOT repeat, rephrase, or summarize your own previous messages. If you have nothing genuinely new to add, respond with [SKIP].
+</dedup>`;
+    } else {
+      context += `
+
+Build on what's been said. Don't repeat points already made. If you have nothing new to add, respond with [SKIP].`;
+    }
+  }
+  const activeProject = projectContext?.activeProject;
+  const mentionedProjects = projectContext?.mentionedProjects ?? [];
+  if (activeProject || mentionedProjects.length > 0) {
+    context += `
+
+<project-context>`;
+    if (activeProject) {
+      context += `
+Active project scope: ${activeProject.name} (${activeProject.slug}, id: ${activeProject.id}).`;
+    }
+    if (mentionedProjects.length > 0) {
+      const blocks = mentionedProjects.map((project) => {
+        const repos = project.repos.length > 0 ? project.repos.map((repo) => {
+          const parts = [repo.name];
+          if (repo.path) parts.push(`path: ${repo.path}`);
+          if (repo.notes) parts.push(`notes: ${repo.notes}`);
+          return `- ${parts.join(" | ")}`;
+        }).join("\n") : "- (none)";
+        const details = [
+          `Project: ${project.name} (${project.slug}, id: ${project.id})`,
+          project.description ? `Description: ${project.description}` : null,
+          project.ciCdInfo ? `CI/CD: ${project.ciCdInfo}` : null,
+          project.workflowId ? `Workflow ID: ${project.workflowId}` : null,
+          `Repos:
+${repos}`
+        ].filter(Boolean).join("\n");
+        return details;
+      });
+      context += `
+Mentioned project details (included only because the user explicitly mentioned them):
+${blocks.join("\n\n")}`;
+    }
+    const projSkills = projectContext?.skills;
+    if (projSkills && projSkills.length > 0) {
+      context += `
+Project knowledge references:`;
+      for (const s of projSkills) {
+        context += `
+- ${s.file}${s.condition ? ` (when: ${s.condition})` : ""}`;
+      }
+    }
+    const projVars = projectContext?.variables;
+    if (projVars && projVars.length > 0) {
+      context += `
+Project variables:`;
+      for (const v of projVars) {
+        context += `
+- ${v.key}: ${v.value}`;
+      }
+    }
+    const projMem = projectContext?.memory;
+    if (projMem && projMem.length > 0) {
+      context += `
+Project knowledge notes:`;
+      for (const m of projMem) {
+        context += `
+- ${m.content}${m.source ? ` (source: ${m.source})` : ""}`;
+      }
+    }
+    const repoKnowledge = projectContext?.repoKnowledge;
+    if (repoKnowledge && repoKnowledge.length > 0) {
+      context += `
+Repo knowledge:`;
+      for (const entry of repoKnowledge) {
+        const label = entry.path ? `${entry.repoName} (${entry.path})` : entry.repoName;
+        context += `
+- ${label}: ${entry.content}`;
+      }
+    }
+    context += `
+</project-context>`;
+  }
+  return context;
+}
+async function runAgent(workspaceId, p, all, active, prompt, transcript, recentHistory, exchangeMessages, currentUserMessageId, projectContext, signal, write, rootMessageId, onRegister) {
+  let fullResponse = "";
+  write({ type: "participant-thinking", participantId: p.id });
+  const vars = Object.fromEntries(
+    (projectContext?.provenanceByAgentId?.[p.id]?.variables ?? projectContext?.variables ?? []).map((entry) => [
+      entry.key,
+      entry.value
+    ])
+  );
+  const interpolate = (text) => Object.keys(vars).length > 0 ? text.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`) : text;
+  let resolvedIdentity = p.identity ? interpolate(p.identity) : p.identity;
+  let selfContent;
+  ensureAgentArtifacts(p, resolvedIdentity);
+  const agentSelf = readSelf(p.id);
+  if (agentSelf?.content) {
+    selfContent = `[Self-Model]
+${agentSelf.content}`;
+  }
+  const executionProvenance = projectContext?.provenanceByAgentId?.[p.id];
+  const resolvedMemory = executionProvenance?.memory ?? [];
+  if (resolvedMemory.length > 0) {
+    const memoryLines = resolvedMemory.map((entry) => `- (${entry.source}) ${entry.content}`);
+    selfContent = [selfContent, `[Knowledge: Agent Derived]
+${memoryLines.join("\n")}`].filter(Boolean).join("\n\n");
+  }
+  let skillsContent;
+  const resolvedSkills = resolveRuntimeSkills(p, projectContext);
+  if (resolvedSkills.length > 0) {
+    const parts = await Promise.all(
+      resolvedSkills.map(async (skill) => {
+        const reference = interpolate(skill.file);
+        const condition = skill.condition ? interpolate(skill.condition) : skill.condition;
+        const resolved = await readReferenceContent(reference);
+        const header = condition ? `--- ${resolved.label} [${skill.source}] ---
+Use when: ${condition}` : `--- ${resolved.label} [${skill.source}] ---`;
+        return `${header}
+${resolved.content}`;
+      })
+    );
+    skillsContent = `[Knowledge References]
+${parts.join("\n\n")}`;
+  }
+  const baseSystemContext = buildContext(
+    p,
+    all,
+    active,
+    transcript,
+    recentHistory,
+    exchangeMessages,
+    currentUserMessageId,
+    projectContext
+  );
+  const systemContext = [
+    baseSystemContext,
+    executionProvenance ? `<execution-provenance>
+Resolved skills: ${executionProvenance.skills.map((skill) => `${skill.file} (${skill.source})`).join(", ") || "none"}
+Resolved variables: ${executionProvenance.variables.map((variable) => `${variable.key} (${variable.source})`).join(", ") || "none"}
+Resolved memory entries: ${executionProvenance.memory.map((entry) => `${entry.source}${entry.id ? `:${entry.id}` : ""}`).join(", ") || "none"}
+</execution-provenance>` : null
+  ].filter(Boolean).join("\n\n");
+  write({
+    type: "log",
+    participantId: p.id,
+    stream: "stdout",
+    line: `[DIAGNOSTIC] Model payload for ${p.id}:
+${JSON.stringify({
+      provider: p.provider,
+      model: p.model,
+      promptLength: prompt.length,
+      identity: resolvedIdentity ? resolvedIdentity.slice(0, 200) + "..." : void 0,
+      self: selfContent ? selfContent.slice(0, 200) + "..." : void 0,
+      skills: skillsContent ? skillsContent.slice(0, 200) + "..." : void 0,
+      provenance: executionProvenance,
+      systemContext: systemContext.slice(0, 500) + "..."
+    }, null, 2)}`
+  });
+  const sinceMessageId = currentUserMessageId || "";
+  const responseMessageId = `${p.id}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const agentProcessId = register({
+    workspaceId,
+    threadId: rootMessageId || "",
+    agentId: p.id,
+    pid: 0,
+    state: "spawning",
+    sinceMessageId,
+    responseMessageId,
+    startedAt: Date.now(),
+    lastActivity: Date.now(),
+    projectSlug: projectContext?.activeProject?.slug || ""
+  });
+  onRegister?.(agentProcessId);
+  let spawnedPid = null;
+  try {
+    await runCliResponse({
+      provider: p.provider,
+      model: p.model,
+      prompt,
+      identity: resolvedIdentity,
+      self: selfContent,
+      skills: skillsContent,
+      systemContext,
+      signal,
+      onSpawn: (pid) => {
+        spawnedPid = pid;
+        update(workspaceId, p.id, { pid, state: "running", lastActivity: Date.now() });
+      },
+      onLog: (stream, line) => {
+        write({ type: "log", participantId: p.id, stream, line });
+      },
+      onDelta: (delta) => {
+        fullResponse += delta;
+        update(workspaceId, p.id, { lastActivity: Date.now() });
+      }
+    });
+    update(workspaceId, p.id, { state: "done", lastActivity: Date.now() });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const isAbort = signal?.aborted;
+    update(workspaceId, p.id, {
+      state: isAbort ? "killed" : "error",
+      lastActivity: Date.now()
+    });
+    logActivity(p.id, "error", { thread: rootMessageId || workspaceId, error: message });
+    write({ type: "participant-error", participantId: p.id, error: message });
+  } finally {
+  }
+  const parsed = parseReactionSignals(fullResponse);
+  for (const bad of parsed.invalid) {
+    write({
+      type: "log",
+      participantId: p.id,
+      stream: "stderr",
+      line: `[reaction] ignored ${bad.raw}: ${bad.error}`
+    });
+  }
+  for (const signalData of parsed.signals) {
+    try {
+      const result = await setReaction({
+        threadId: workspaceId,
+        messageId: signalData.target,
+        participantId: p.id,
+        type: signalData.type,
+        reason: signalData.reason,
+        blockerCode: signalData.blockerCode,
+        hostPid: spawnedPid,
+        responseMessageId
+      });
+      write({
+        type: "message-reactions",
+        messageId: signalData.target,
+        reactions: result.reactions
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      write({
+        type: "log",
+        participantId: p.id,
+        stream: "stderr",
+        line: `[reaction] failed ${signalData.raw}: ${message}`
+      });
+    }
+  }
+  const trimmed = parsed.cleanedText.trim();
+  if (trimmed === SKIP_SIGNAL) {
+    logActivity(p.id, "skip", { thread: rootMessageId || workspaceId });
+    write({ type: "participant-end", participantId: p.id });
+    return {
+      skipped: true,
+      response: "",
+      mentions: /* @__PURE__ */ new Set(),
+      parallel: false,
+      parallelIds: /* @__PURE__ */ new Set(),
+      agentProcessId
+    };
+  }
+  const cleanResponse = cleanParallelMentions(trimmed, all);
+  let messageId;
+  if (cleanResponse) {
+    try {
+      await saveMessages(workspaceId, [
+        {
+          id: responseMessageId,
+          role: "assistant",
+          participantId: p.id,
+          content: cleanResponse,
+          timestamp: Date.now(),
+          rootMessageId: rootMessageId || null,
+          parentMessageId: rootMessageId || null,
+          depth: rootMessageId ? 1 : 0
+        }
+      ]);
+      messageId = responseMessageId;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      write({
+        type: "log",
+        participantId: p.id,
+        stream: "stderr",
+        line: `[history] failed to save assistant message: ${message}`
+      });
+    }
+  }
+  if (cleanResponse && cleanResponse.length > 20) {
+    try {
+      ensureAgentArtifacts(p, resolvedIdentity);
+      const insights = derivePerMessageJournalInsights(cleanResponse);
+      const journalEntry = appendJournal(p.id, {
+        t: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "post",
+        thread: rootMessageId || workspaceId,
+        observation: `Responded to thread`,
+        judgement: insights.judgement,
+        delta: insights.delta,
+        intent: insights.intent
+      });
+    } catch {
+    }
+  }
+  if (cleanResponse) {
+    ensureAgentArtifacts(p, resolvedIdentity);
+    const count = (agentMessageCounts.get(p.id) || 0) + 1;
+    agentMessageCounts.set(p.id, count);
+    if (count % REFLECTION_CADENCE === 0) {
+      enqueueReflection(p).catch(() => {
+      });
+    }
+  }
+  const { ids: rawMentions, parallel: rawParallelIds } = cleanResponse ? findMentions(cleanResponse, all) : { ids: /* @__PURE__ */ new Set(), parallel: /* @__PURE__ */ new Set() };
+  rawMentions.delete(p.id);
+  rawParallelIds.delete(p.id);
+  const mentions = rawMentions;
+  const parallelIds = rawParallelIds;
+  if (cleanResponse) {
+    const reactionTypes = parsed.signals.map((s) => s.type);
+    logActivity(p.id, "message", {
+      thread: rootMessageId || workspaceId,
+      messageId,
+      response: cleanResponse,
+      prompt,
+      mentions: mentions.size > 0 ? [...mentions] : void 0,
+      reactions: reactionTypes.length > 0 ? reactionTypes : void 0
+    });
+  }
+  write({ type: "participant-end", participantId: p.id, messageId, content: cleanResponse || void 0 });
+  if (!cleanResponse) {
+    return {
+      skipped: true,
+      response: "",
+      mentions: /* @__PURE__ */ new Set(),
+      parallel: false,
+      parallelIds: /* @__PURE__ */ new Set(),
+      agentProcessId
+    };
+  }
+  const hasParallel = parallelIds.size > 0;
+  return {
+    skipped: false,
+    response: cleanResponse,
+    mentions,
+    parallel: hasParallel,
+    parallelIds,
+    messageId,
+    agentProcessId
+  };
+}
+function createMultiplexedStream({
+  threadId: workspaceId,
+  allParticipants,
+  mentioned,
+  initialParallelIds,
+  prompt,
+  projectContext,
+  signal,
+  maxRounds,
+  recentHistory,
+  currentUserMessageId,
+  rootMessageId
+}) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const logBuffer = [];
+      const agentProcessIds = /* @__PURE__ */ new Map();
+      const write = (event) => {
+        try {
+          controller.enqueue(encoder.encode(sseEncode(event)));
+        } catch {
+        }
+        if (event.type === "log") {
+          const processId = agentProcessIds.get(event.participantId);
+          if (processId) {
+            logBuffer.push({
+              agentProcessId: processId,
+              stream: event.stream,
+              line: event.line,
+              timestamp: Date.now()
+            });
+          }
+        }
+      };
+      const flushLogs = async () => {
+        if (logBuffer.length === 0) return;
+        const byProcess = /* @__PURE__ */ new Map();
+        for (const entry of logBuffer) {
+          let batch = byProcess.get(entry.agentProcessId);
+          if (!batch) {
+            batch = [];
+            byProcess.set(entry.agentProcessId, batch);
+          }
+          batch.push({ stream: entry.stream, line: entry.line, timestamp: entry.timestamp });
+        }
+        await Promise.all(
+          Array.from(byProcess.entries()).map(
+            ([processId, entries]) => saveLogs(processId, entries).catch(() => {
+            })
+          )
+        );
+      };
+      const transcript = [];
+      const exchangeMessages = [];
+      const priorMessages = recentHistory ? recentHistory.map((m) => ({ name: m.name, content: m.content })) : [];
+      const main2 = allParticipants[0];
+      const activeIds = /* @__PURE__ */ new Set();
+      if (mentioned.size > 0) {
+        for (const id of mentioned) activeIds.add(id);
+      } else {
+        activeIds.add(main2.id);
+      }
+      const rounds = maxRounds ?? DEFAULT_MAX_ROUNDS;
+      let addressedThisRound = new Set(activeIds);
+      for (let round = 0; round < rounds; round++) {
+        if (signal?.aborted) break;
+        let allSkipped = true;
+        const activeList = allParticipants.filter((p) => activeIds.has(p.id));
+        const addressedNextRound = /* @__PURE__ */ new Set();
+        const alreadyRanThisRound = /* @__PURE__ */ new Set();
+        if (round === 0 && initialParallelIds && initialParallelIds.size > 0) {
+          const initialParallelAgents = activeList.filter(
+            (agent) => initialParallelIds.has(agent.id) && addressedThisRound.has(agent.id)
+          );
+          if (initialParallelAgents.length > 0) {
+            for (const agent of initialParallelAgents) {
+              alreadyRanThisRound.add(agent.id);
+            }
+            const tasks = initialParallelAgents.map(async (agent) => {
+              const result = await runAgent(
+                workspaceId,
+                agent,
+                allParticipants,
+                activeList,
+                prompt,
+                transcript,
+                recentHistory || [],
+                exchangeMessages,
+                currentUserMessageId || null,
+                projectContext,
+                signal,
+                write,
+                rootMessageId,
+                (id) => agentProcessIds.set(agent.id, id)
+              );
+              return { agent, result };
+            });
+            const results = await Promise.allSettled(tasks);
+            for (const settled of results) {
+              if (settled.status !== "fulfilled") continue;
+              const { agent, result } = settled.value;
+              if (result.skipped) continue;
+              if (result.response && result.messageId) {
+                exchangeMessages.push({
+                  id: result.messageId,
+                  name: agent.name,
+                  content: result.response
+                });
+              }
+              if (result.response) {
+                const allPrev = [...priorMessages, ...transcript].filter((t) => t.name === agent.name);
+                const isRepetitive = allPrev.some(
+                  (prev) => similarity(prev.content, result.response) > SIMILARITY_THRESHOLD
+                );
+                if (!isRepetitive) {
+                  transcript.push({ name: agent.name, content: result.response });
+                  allSkipped = false;
+                }
+              }
+              for (const id of result.mentions) {
+                activeIds.add(id);
+                const mentionedIdx = activeList.findIndex((a) => a.id === id);
+                const isPendingInThisRound = mentionedIdx >= 0 && !alreadyRanThisRound.has(id) && addressedThisRound.has(id);
+                if (!isPendingInThisRound) {
+                  addressedNextRound.add(id);
+                }
+              }
+            }
+          }
+        }
+        for (let i = 0; i < activeList.length; i++) {
+          const p = activeList[i];
+          if (signal?.aborted) break;
+          if (!addressedThisRound.has(p.id)) continue;
+          if (alreadyRanThisRound.has(p.id)) continue;
+          const result = await runAgent(
+            workspaceId,
+            p,
+            allParticipants,
+            activeList,
+            prompt,
+            transcript,
+            recentHistory || [],
+            exchangeMessages,
+            currentUserMessageId || null,
+            projectContext,
+            signal,
+            write,
+            rootMessageId,
+            (id) => agentProcessIds.set(p.id, id)
+          );
+          if (result.skipped) continue;
+          if (result.response && result.messageId) {
+            exchangeMessages.push({
+              id: result.messageId,
+              name: p.name,
+              content: result.response
+            });
+          }
+          if (result.response) {
+            const allPrev = [...priorMessages, ...transcript].filter((t) => t.name === p.name);
+            const isRepetitive = allPrev.some((prev) => similarity(prev.content, result.response) > SIMILARITY_THRESHOLD);
+            if (isRepetitive) continue;
+          }
+          allSkipped = false;
+          if (result.response) {
+            transcript.push({ name: p.name, content: result.response });
+          }
+          for (const id of result.mentions) {
+            const mentionedIdx = activeList.findIndex((a) => a.id === id);
+            const isPendingInThisRound = mentionedIdx > i && addressedThisRound.has(id);
+            if (!isPendingInThisRound) {
+              addressedNextRound.add(id);
+            }
+          }
+          const newlyInvited = /* @__PURE__ */ new Set();
+          for (const id of result.mentions) {
+            if (!activeIds.has(id)) {
+              activeIds.add(id);
+              newlyInvited.add(id);
+            }
+          }
+          const newParallelIds = new Set([...result.parallelIds].filter((id) => newlyInvited.has(id)));
+          if (newParallelIds.size > 0) {
+            const parallelAgents = allParticipants.filter((a) => newParallelIds.has(a.id));
+            const updatedActiveList = allParticipants.filter((a) => activeIds.has(a.id));
+            const tasks = parallelAgents.map(async (a) => {
+              const r = await runAgent(
+                workspaceId,
+                a,
+                allParticipants,
+                updatedActiveList,
+                prompt,
+                transcript,
+                recentHistory || [],
+                exchangeMessages,
+                currentUserMessageId || null,
+                projectContext,
+                signal,
+                write,
+                rootMessageId,
+                (id) => agentProcessIds.set(a.id, id)
+              );
+              return { agent: a, result: r };
+            });
+            const results = await Promise.allSettled(tasks);
+            for (const settled of results) {
+              if (settled.status !== "fulfilled") continue;
+              const { agent, result: r } = settled.value;
+              if (r.skipped) continue;
+              if (r.response && r.messageId) {
+                exchangeMessages.push({
+                  id: r.messageId,
+                  name: agent.name,
+                  content: r.response
+                });
+              }
+              if (r.response) {
+                const allPrev = [...priorMessages, ...transcript].filter((t) => t.name === agent.name);
+                const isRepetitive = allPrev.some((prev) => similarity(prev.content, r.response) > SIMILARITY_THRESHOLD);
+                if (isRepetitive) continue;
+                transcript.push({ name: agent.name, content: r.response });
+              }
+              for (const id of r.mentions) {
+                activeIds.add(id);
+                addressedNextRound.add(id);
+              }
+            }
+          }
+        }
+        if (allSkipped) break;
+        addressedThisRound = addressedNextRound;
+      }
+      await flushLogs();
+      write({ type: "done" });
+      controller.close();
+    }
+  });
+}
+
+// ../agx-cloud/lib/agent-participants.ts
+init_db();
+init_auth_mode();
+async function loadDbParticipants() {
+  const agents = await getAgents(LOCAL_USER.id);
+  const skillsByAgent = /* @__PURE__ */ new Map();
+  await Promise.all(
+    agents.map(async (agent) => {
+      skillsByAgent.set(agent.id, await getAgentSkills(agent.id));
+    })
+  );
+  return agents.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    provider: agent.provider || "claude",
+    model: agent.model || null,
+    color: agent.color || "#6B7280",
+    ...agent.description ? { identity: agent.description } : {},
+    ...skillsByAgent.get(agent.id)?.length ? {
+      skills: skillsByAgent.get(agent.id).map((skill) => ({
+        file: skill.file,
+        condition: skill.condition ?? ""
+      }))
+    } : {}
+  }));
+}
+
+// ../agx-cloud/lib/orchestrator/chat-activities.ts
+async function loadChatRunActivity(chatRunId) {
+  return getChatRun(chatRunId);
+}
+async function updateChatRunActivity(input) {
+  return updateChatRun(input);
+}
+async function appendChatRunStepActivity(input) {
+  const existingSteps = await listChatRunSteps(input.chatRunId);
+  return appendChatRunStep({
+    id: crypto.randomUUID(),
+    chatRunId: input.chatRunId,
+    stepIndex: existingSteps.length + 1,
+    kind: input.kind,
+    status: input.status,
+    participantId: input.participantId,
+    inputPayload: input.inputPayload,
+    outputPayload: input.outputPayload
+  });
+}
+async function completeChatRunStepActivity(input) {
+  return updateChatRunStep({
+    id: input.stepId,
+    status: input.status,
+    outputPayload: input.outputPayload,
+    completedAt: Date.now()
+  });
+}
+
+// ../agx-cloud/lib/orchestrator/chat-processor.ts
+function isChatRunPayload(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return Boolean(
+    typeof candidate.threadId === "string" && typeof candidate.prompt === "string" && Array.isArray(candidate.participantIds)
+  );
+}
+async function handleStart2(job) {
+  const chatRun = await loadChatRunActivity(job.data.chatRunId);
+  if (!chatRun) {
+    console.warn(`[chat-processor] Chat run ${job.data.chatRunId} not found, skipping`);
+    return;
+  }
+  if (chatRun.status === "completed" || chatRun.status === "failed" || chatRun.status === "cancelled") {
+    return;
+  }
+  if (!isChatRunPayload(chatRun.payload)) {
+    await updateChatRunActivity({
+      id: chatRun.id,
+      status: "failed",
+      lastError: "Chat run payload is missing or invalid",
+      completedAt: Date.now()
+    });
+    return;
+  }
+  const step = await appendChatRunStepActivity({
+    chatRunId: chatRun.id,
+    kind: "model_turn",
+    status: "running",
+    inputPayload: {
+      participantIds: chatRun.payload.participantIds,
+      rootMessageId: chatRun.payload.rootMessageId,
+      maxRounds: chatRun.payload.maxRounds
+    }
+  });
+  await updateChatRunActivity({
+    id: chatRun.id,
+    status: "running",
+    currentStep: step.stepIndex,
+    stepsUsed: step.stepIndex,
+    lastError: null
+  });
+  try {
+    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) {
+      throw new Error("No participants resolved for chat run");
+    }
+    const mentioned = new Set(
+      chatRun.payload.mentionedIds.filter((participantId) => participantIdSet.has(participantId))
+    );
+    const initialParallelIds = new Set(
+      chatRun.payload.initialParallelIds.filter((participantId) => participantIdSet.has(participantId))
+    );
+    const stream = createMultiplexedStream({
+      threadId: chatRun.payload.threadId,
+      allParticipants: participants,
+      mentioned,
+      initialParallelIds,
+      prompt: chatRun.payload.prompt,
+      projectContext: chatRun.payload.projectContext,
+      maxRounds: chatRun.payload.maxRounds,
+      recentHistory: chatRun.payload.recentHistory,
+      currentUserMessageId: chatRun.payload.currentUserMessageId,
+      rootMessageId: chatRun.payload.rootMessageId
+    });
+    const reader = stream.getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) break;
+    }
+    await completeChatRunStepActivity({
+      stepId: step.id,
+      status: "completed",
+      outputPayload: {
+        completed: true,
+        participantCount: participants.length
+      }
+    });
+    await updateChatRunActivity({
+      id: chatRun.id,
+      status: "completed",
+      completedAt: Date.now(),
+      result: {
+        participantIds: participants.map((participant) => participant.id),
+        rootMessageId: chatRun.payload.rootMessageId
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await completeChatRunStepActivity({
+      stepId: step.id,
+      status: "failed",
+      outputPayload: { error: message }
+    });
+    await updateChatRunActivity({
+      id: chatRun.id,
+      status: "failed",
+      lastError: message,
+      completedAt: Date.now(),
+      result: { error: message }
+    });
+  }
+}
+async function handleCancel2(job) {
+  const chatRun = await loadChatRunActivity(job.data.chatRunId);
+  if (!chatRun) return;
+  if (chatRun.rootMessageId) {
+    killByThread(chatRun.rootMessageId);
+  } else {
+    killByWorkspace(chatRun.threadId);
+  }
+  await updateChatRunActivity({
+    id: chatRun.id,
+    status: "cancelled",
+    lastError: job.data.payload?.reason || "Cancelled",
+    completedAt: Date.now(),
+    result: { cancelled: true }
+  });
+}
+async function processSingleJob2(job) {
+  switch (job.data.signal) {
+    case "start":
+      await handleStart2(job);
+      break;
+    case "cancel":
+      await handleCancel2(job);
+      break;
+    default:
+      console.warn(`[chat-processor] Unknown signal: ${job.data.signal}`);
+  }
+}
+async function chatProcessor(jobs) {
+  for (const job of jobs) {
+    await processSingleJob2(job);
+  }
+}
+
+// ../agx-cloud/worker/index.ts
+async function main() {
+  const requestedWorkers = Number(process.env.AGX_WORKER_COUNT) || 1;
+  assertWorkerCount(requestedWorkers);
+  console.log(`[worker] Starting SQLite worker (${requestedWorkers}/${MAX_WORKERS} max)...`);
+  const queue2 = await getQueue();
+  await queue2.work(
+    QUEUE_NAMES.TASK_PROCESS,
+    taskProcessor,
+    { batchSize: 5 }
+  );
+  await queue2.work(
+    QUEUE_NAMES.CHAT_RUN_PROCESS,
+    chatProcessor,
+    { batchSize: 2 }
   );
   console.log(`[worker] Listening on queue: ${QUEUE_NAMES.TASK_PROCESS}`);
+  console.log(`[worker] Listening on queue: ${QUEUE_NAMES.CHAT_RUN_PROCESS}`);
   const shutdown = async (signal) => {
     console.log(`[worker] Received ${signal}, shutting down...`);
     await stopQueue();