@askexenow/exe-os 0.9.166 → 0.9.167

package/dist/{chunk-AR3OYGLB.js → chunk-PEFBRL4S.js}

@@ -3,24 +3,24 @@ import {
 } from "./chunk-MLXJ5EZG.js";
 import {
   createTask
-} from "./chunk-ZWS6XQER.js";
+} from "./chunk-F5AKOE4P.js";
 import {
   getActiveAgent
-} from "./chunk-6WG2VIKC.js";
+} from "./chunk-LM7H6XU4.js";
 import {
   ensureEmployee,
   logTaskDispatch,
   resolveExeSession
-} from "./chunk-W7SDGBEC.js";
+} from "./chunk-MFI5OXYW.js";
 import {
   getLicenseSync
-} from "./chunk-HLVQ5Y7B.js";
+} from "./chunk-RE4VLK45.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
 import {
   isCoordinatorName
-} from "./chunk-5RSYY7BE.js";
+} from "./chunk-SJYOPYXH.js";
 
 // src/mcp/tools/create-task.ts
 import { z } from "zod";
@@ -185,7 +185,7 @@ function registerCreateTask(server) {
             let projectConflictOpts = {};
             try {
               const { getClient } = await import("./lib/database.js");
-              const { sessionScopeFilter } = await import("./task-scope-2N45TE32.js");
+              const { sessionScopeFilter } = await import("./task-scope-W73Z3XWE.js");
               const client = getClient();
               const scope = sessionScopeFilter();
               const existing = await client.execute({
@@ -228,6 +228,28 @@ Dispatched: spawned ${result.sessionName}`;
 Dispatch failed: ${result.error ?? "unknown"}`;
                 break;
             }
+            try {
+              const { sendIntercom: si } = await import("./lib/tmux-routing.js");
+              const { listTmuxSessions } = await import("./lib/tmux-status.js");
+              const liveSessions = listTmuxSessions();
+              for (const s of liveSessions) {
+                const agentPart = s.split("-")[0]?.replace(/\d+$/, "") ?? "";
+                if (agentPart === assigned_to && s !== result.sessionName) {
+                  si(s, { force: true });
+                }
+              }
+            } catch {
+            }
+            if (result.sessionName && result.status === "spawned") {
+              try {
+                const { getClient: gc } = await import("./lib/database.js");
+                await gc().execute({
+                  sql: "UPDATE tasks SET instance_id = ? WHERE id = ?",
+                  args: [result.sessionName, task.id]
+                });
+              } catch {
+              }
+            }
             try {
               writeDispatchPending(task.id, assigned_to, result.sessionName);
             } catch {

package/dist/{chunk-AEUXUEJG.js → chunk-PEXVU3HU.js}

@@ -1,9 +1,9 @@
 import {
   getActiveAgent
-} from "./chunk-6WG2VIKC.js";
+} from "./chunk-LM7H6XU4.js";
 import {
   listTasks
-} from "./chunk-W7SDGBEC.js";
+} from "./chunk-MFI5OXYW.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";
@@ -43,12 +43,14 @@ function registerListTasks(server) {
         } else {
           resolvedProject = getProjectName() || void 0;
         }
+        const { canCoordinate: canCoord } = await import("./lib/employees.js");
+        const effectiveCrossSession = canCoord(agentId, agentRole) ? cross_session ?? false : false;
         const tasks = await listTasks({
           assignedTo: assigned_to,
           status,
           projectName: resolvedProject,
           priority,
-          crossSession: cross_session ?? false
+          crossSession: effectiveCrossSession
         });
         if (tasks.length === 0) {
           return {

package/dist/chunk-Q2G5C3HV.js

@@ -0,0 +1,217 @@
+// src/lib/conversation-parser.ts
+function detectFormat(content, filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".md") || lower.endsWith(".markdown")) {
+    return "markdown";
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      const first = parsed[0];
+      if (first && typeof first === "object") {
+        if ("mapping" in first && typeof first.mapping === "object") {
+          return "chatgpt";
+        }
+        if (("chat_messages" in first || "messages" in first) && ("name" in first || "uuid" in first)) {
+          return "claude";
+        }
+        if ("role" in first && "content" in first) {
+          return "generic";
+        }
+      }
+    }
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      if ("mapping" in parsed) return "chatgpt";
+      if ("chat_messages" in parsed || "messages" in parsed) return "claude";
+    }
+  } catch {
+  }
+  return "generic";
+}
+function parseChatGPT(content, sourceFile) {
+  const raw = JSON.parse(content);
+  const conversations = Array.isArray(raw) ? raw : [raw];
+  const results = [];
+  for (const convo of conversations) {
+    if (!convo.mapping) continue;
+    const messages = [];
+    const nodes = Object.values(convo.mapping);
+    const sorted = nodes.filter(
+      (n) => !!n.message?.content?.parts && n.message.author?.role !== "system"
+    ).sort((a, b) => (a.message.create_time ?? 0) - (b.message.create_time ?? 0));
+    for (const node of sorted) {
+      const role = node.message.author?.role ?? "unknown";
+      const parts = node.message.content?.parts ?? [];
+      const textParts = parts.filter((p) => typeof p === "string");
+      const text = textParts.join("\n").trim();
+      if (!text) continue;
+      messages.push({
+        role,
+        content: text,
+        timestamp: node.message.create_time ? new Date(node.message.create_time * 1e3).toISOString() : void 0
+      });
+    }
+    if (messages.length > 0) {
+      results.push({
+        title: convo.title ?? "Untitled ChatGPT Conversation",
+        messages,
+        sourceFile
+      });
+    }
+  }
+  return results;
+}
+function parseClaude(content, sourceFile) {
+  const raw = JSON.parse(content);
+  const conversations = Array.isArray(raw) ? raw : [raw];
+  const results = [];
+  for (const convo of conversations) {
+    const rawMessages = convo.chat_messages ?? convo.messages ?? [];
+    const messages = [];
+    for (const msg of rawMessages) {
+      const role = msg.sender ?? msg.role ?? "unknown";
+      let text;
+      if (typeof msg.text === "string") {
+        text = msg.text;
+      } else if (typeof msg.content === "string") {
+        text = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        text = msg.content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
+      } else {
+        continue;
+      }
+      text = text.trim();
+      if (!text) continue;
+      messages.push({
+        role: normalizeRole(role),
+        content: text,
+        timestamp: msg.created_at ?? msg.timestamp
+      });
+    }
+    if (messages.length > 0) {
+      results.push({
+        title: convo.name ?? convo.uuid ?? "Untitled Claude Conversation",
+        messages,
+        sourceFile
+      });
+    }
+  }
+  return results;
+}
+function parseGeneric(content, sourceFile) {
+  try {
+    const raw = JSON.parse(content);
+    const messages = Array.isArray(raw) ? raw : raw.messages ?? [];
+    const title = !Array.isArray(raw) ? raw.title : void 0;
+    const parsed = [];
+    for (const msg of messages) {
+      const text = (msg.content ?? msg.text ?? "").trim();
+      if (!text) continue;
+      parsed.push({
+        role: normalizeRole(msg.role ?? "unknown"),
+        content: text,
+        timestamp: msg.timestamp ?? msg.created_at
+      });
+    }
+    if (parsed.length > 0) {
+      return [{
+        title: title ?? `Imported from ${sourceFile}`,
+        messages: parsed,
+        sourceFile
+      }];
+    }
+  } catch {
+  }
+  return parseMarkdown(content, sourceFile);
+}
+function parseMarkdown(content, sourceFile) {
+  const lines = content.split("\n");
+  const messages = [];
+  let currentRole = "unknown";
+  let currentContent = [];
+  const ROLE_PATTERNS = [
+    /^#{1,3}\s+(User|Human|Assistant|AI|System|Claude|GPT|Bot)\s*$/i,
+    /^\*\*(User|Human|Assistant|AI|System|Claude|GPT|Bot)\*?\*?:?\s*/i,
+    /^(User|Human|Assistant|AI|System|Claude|GPT|Bot)\s*:\s*/i
+  ];
+  function flushMessage() {
+    const text = currentContent.join("\n").trim();
+    if (text) {
+      messages.push({ role: normalizeRole(currentRole), content: text });
+    }
+    currentContent = [];
+  }
+  for (const line of lines) {
+    let matched = false;
+    for (const pattern of ROLE_PATTERNS) {
+      const match = line.match(pattern);
+      if (match) {
+        flushMessage();
+        currentRole = match[1];
+        const remaining = line.replace(pattern, "").trim();
+        if (remaining) currentContent.push(remaining);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      currentContent.push(line);
+    }
+  }
+  flushMessage();
+  if (messages.length === 0) {
+    const text = content.trim();
+    if (text) {
+      messages.push({ role: "unknown", content: text });
+    }
+  }
+  return messages.length > 0 ? [{ title: `Imported from ${sourceFile}`, messages, sourceFile }] : [];
+}
+function conversationsToMemories(conversations, format) {
+  const memories = [];
+  for (const convo of conversations) {
+    for (const msg of convo.messages) {
+      if (msg.content.length < 10) continue;
+      memories.push({
+        text: `[${convo.title}] ${msg.role}: ${msg.content}`,
+        kind: "conversation",
+        metadata: {
+          source_type: "import",
+          source_format: format,
+          source_path: convo.sourceFile,
+          conversation_title: convo.title,
+          role: msg.role,
+          original_timestamp: msg.timestamp
+        }
+      });
+    }
+  }
+  return memories;
+}
+function normalizeRole(role) {
+  const lower = role.toLowerCase().trim();
+  switch (lower) {
+    case "human":
+    case "user":
+      return "user";
+    case "assistant":
+    case "ai":
+    case "bot":
+    case "claude":
+    case "gpt":
+    case "chatgpt":
+      return "assistant";
+    case "system":
+      return "system";
+    default:
+      return lower;
+  }
+}
+
+export {
+  detectFormat,
+  parseChatGPT,
+  parseClaude,
+  parseGeneric,
+  conversationsToMemories
+};

package/dist/{chunk-KOO56JVC.js → chunk-Q6N6LDEJ.js}

@@ -7,7 +7,7 @@ import {
 import {
   connectEmbedDaemon,
   embedBatchViaClient
-} from "./chunk-G4FDG3LK.js";
+} from "./chunk-UVNDLF74.js";
 import {
   EXE_AI_DIR
 } from "./chunk-4GXRETYL.js";

package/dist/{chunk-TXSJ2L5O.js → chunk-QI4IXJN7.js}

@@ -3,7 +3,7 @@ import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, appendF
 import path from "path";
 import os from "os";
 var QUEUE_PATH = path.join(os.homedir(), ".exe-os", "intercom-queue.json");
-var MAX_RETRIES = 5;
+var MAX_RETRIES = 10;
 var TTL_MS = 60 * 60 * 1e3;
 function ensureDir() {
   const dir = path.dirname(QUEUE_PATH);

package/dist/{chunk-HLVQ5Y7B.js → chunk-RE4VLK45.js}

@@ -3,7 +3,7 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-5RSYY7BE.js";
+} from "./chunk-SJYOPYXH.js";
 import {
   PLAN_LIMITS,
   checkLicense,

package/dist/{chunk-TF6SZGDT.js → chunk-SA2PH6WY.js}

@@ -1,6 +1,6 @@
 import {
   createReminder
-} from "./chunk-TH22QIEC.js";
+} from "./chunk-6A4COFDG.js";
 
 // src/mcp/tools/create-reminder.ts
 import { z } from "zod";

package/dist/{chunk-5RSYY7BE.js → chunk-SJYOPYXH.js}

@@ -329,10 +329,7 @@ function baseAgentName(name, employees) {
 var MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set([
   "principal engineer",
   "content production specialist",
-  "staff code reviewer",
-  "cto",
-  "cmo",
-  "gm"
+  "staff code reviewer"
 ]);
 function isMultiInstance(agentName, employees) {
   const roster = employees ?? loadEmployeesSync();
@@ -1442,33 +1439,81 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_memories_agent_project
       ON memories(agent_id, project_name);
   `);
+  try {
+    await client.execute("ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (!msg.includes("duplicate column")) {
+      logCatchDebug("migration", e);
+    }
+  }
+  try {
+    await client.execute("ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (!msg.includes("duplicate column")) {
+      logCatchDebug("migration", e);
+    }
+  }
+  let needsFtsMigration = false;
+  try {
+    const ftsCheck = await client.execute(
+      "SELECT sql FROM sqlite_master WHERE type='table' AND name='memories_fts'"
+    );
+    const ftsSql = ftsCheck.rows[0]?.sql ?? "";
+    needsFtsMigration = ftsSql.length > 0 && !ftsSql.includes("keywords");
+    if (ftsCheck.rows.length === 0) {
+      needsFtsMigration = true;
+    }
+  } catch {
+    needsFtsMigration = true;
+  }
+  if (needsFtsMigration) {
+    try {
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_ai");
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_ad");
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_au");
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_soft_delete");
+      await client.execute("DROP TABLE IF EXISTS memories_fts");
+    } catch (e) {
+      logCatchDebug("fts-migration-drop", e);
+    }
+  }
   await client.executeMultiple(`
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
       raw_text,
+      keywords,
       content='memories',
       content_rowid='rowid'
     );
 
     CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
     END;
 
     CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
     END;
 
     CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories
     WHEN new.status IS NULL OR new.status != 'deleted' BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
     END;
 
     -- Soft-delete trigger: remove from FTS when status changes to 'deleted'
     CREATE TRIGGER IF NOT EXISTS memories_fts_soft_delete AFTER UPDATE ON memories
     WHEN new.status = 'deleted' AND (old.status IS NULL OR old.status != 'deleted') BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
     END;
   `);
+  if (needsFtsMigration) {
+    try {
+      await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+    } catch (e) {
+      logCatchDebug("fts-rebuild", e);
+    }
+  }
   try {
     await client.execute("SELECT COUNT(*) FROM memories_fts LIMIT 1");
   } catch (ftsErr) {
@@ -1672,6 +1717,14 @@ async function ensureSchema() {
   } catch (e) {
     logCatchDebug("migration", e);
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN instance_id TEXT`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -3148,6 +3201,61 @@ async function ensureSchema() {
   } catch (e) {
     logCatchDebug("migration", e);
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute("SELECT keywords FROM memories_fts LIMIT 0");
+  } catch {
+    process.stderr.write("[database] Upgrading FTS5 to dual-column (raw_text + keywords)...\n");
+    try {
+      await client.executeMultiple(`
+        DROP TRIGGER IF EXISTS memories_fts_ai;
+        DROP TRIGGER IF EXISTS memories_fts_ad;
+        DROP TRIGGER IF EXISTS memories_fts_au;
+        DROP TRIGGER IF EXISTS memories_fts_soft_delete;
+        DROP TABLE IF EXISTS memories_fts;
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+          raw_text,
+          keywords,
+          content='memories',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories
+        WHEN new.status IS NULL OR new.status != 'deleted' BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+          INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_soft_delete AFTER UPDATE ON memories
+        WHEN new.status = 'deleted' AND (old.status IS NULL OR old.status != 'deleted') BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+        END;
+      `);
+      await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+      process.stderr.write("[database] FTS5 dual-column upgrade complete.\n");
+    } catch (ftsUpgradeErr) {
+      process.stderr.write(
+        `[database] FTS5 upgrade failed: ${ftsUpgradeErr instanceof Error ? ftsUpgradeErr.message : String(ftsUpgradeErr)}
+`
+      );
+    }
+  }
 }
 var disposeTurso = disposeDatabase;
 async function disposeDatabase() {

package/dist/{chunk-PJGHBANY.js → chunk-TTJE7CCU.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-5RSYY7BE.js";
+} from "./chunk-SJYOPYXH.js";
 
 // src/lib/behaviors.ts
 import crypto from "crypto";

package/dist/{chunk-A7KEWR6S.js → chunk-TXWQPL2U.js}

@@ -1,6 +1,6 @@
 import {
   TmuxTransport
-} from "./chunk-X347L57O.js";
+} from "./chunk-CSTJQDOE.js";
 
 // src/lib/transport.ts
 var _transport = null;

package/dist/{chunk-XXSJ35J5.js → chunk-U5ZH52FB.js}

@@ -1,12 +1,12 @@
 import {
   PLATFORM_PROCEDURE_TITLES
-} from "./chunk-TPC3LAP7.js";
+} from "./chunk-LGY2BIOT.js";
 import {
   getClient,
   getIdentity,
   listIdentities,
   updateIdentity
-} from "./chunk-5RSYY7BE.js";
+} from "./chunk-SJYOPYXH.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-LYH5HE24.js";