@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-F7LU65PQ.js

@@ -0,0 +1,33 @@
+// src/lib/secret-redaction.ts
+var SECRET_PATTERNS = [
+  { name: "openai_key", pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
+  { name: "anthropic_key", pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+  { name: "exe_license_key", pattern: /\bexe_sk_[A-Za-z0-9_-]{8,}\b/g },
+  { name: "aws_access_key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+  { name: "github_token", pattern: /\bgh[pousr]_[A-Za-z0-9_]{30,}\b/g },
+  { name: "bearer_token", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}\b/gi },
+  { name: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
+  { name: "private_key", pattern: /-----BEGIN (?:OPENSSH|RSA|DSA|EC|PGP)? ?PRIVATE KEY-----[\s\S]*?-----END (?:OPENSSH|RSA|DSA|EC|PGP)? ?PRIVATE KEY-----/g },
+  { name: "db_url_password", pattern: /\b(postgres(?:ql)?|mysql|mongodb|redis):\/\/([^:\s/@]+):([^@\s]+)@/gi },
+  { name: "assignment_secret", pattern: /\b(api[_-]?key|secret|token|password|passwd|pwd|private[_-]?key|access[_-]?key)\s*[:=]\s*(['\"]?)[^\s'"]{8,}\2/gi },
+  { name: "env_secret", pattern: /\b[A-Z0-9_]*(?:API_KEY|SECRET|TOKEN|PASSWORD|PASSWD|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*\s*=\s*['\"]?[^'"\s]{8,}/g },
+  { name: "recovery_phrase", pattern: /\b(?:[a-z]{3,12}\s+){23}[a-z]{3,12}\b/gi }
+];
+function redactSecrets(input) {
+  let text = input;
+  let redactedCount = 0;
+  for (const { name, pattern } of SECRET_PATTERNS) {
+    text = text.replace(pattern, (_match, ...args) => {
+      redactedCount++;
+      if (name === "db_url_password" && typeof args[0] === "string" && typeof args[1] === "string") {
+        return `${args[0]}://${args[1]}:[REDACTED:${name}]@`;
+      }
+      return `[REDACTED:${name}]`;
+    });
+  }
+  return { text, redactedCount };
+}
+
+export {
+  redactSecrets
+};

package/dist/chunk-FF62UWIJ.js

@@ -0,0 +1,90 @@
+import {
+  loadEmployeesSync
+} from "./chunk-UJOSFVWG.js";
+
+// src/adapters/mcp-http-config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var DEFAULT_MCP_HTTP_PORT = "48739";
+function resolveDefaultAgentId() {
+  if (process.env.AGENT_ID && process.env.AGENT_ID !== "default") return process.env.AGENT_ID;
+  try {
+    const coo = loadEmployeesSync().find((e) => e.role === "COO");
+    if (coo) return coo.name;
+  } catch {
+  }
+  return "exe";
+}
+var DEFAULT_MCP_HTTP_AGENT_ID = resolveDefaultAgentId();
+var DEFAULT_MCP_HTTP_AGENT_ROLE = "COO";
+function mcpHttpPort() {
+  return process.env.EXE_MCP_PORT || DEFAULT_MCP_HTTP_PORT;
+}
+function mcpHttpUrl() {
+  return `http://127.0.0.1:${mcpHttpPort()}/mcp`;
+}
+function readOrCreateDaemonToken(homeDir = os.homedir()) {
+  const exeDir = path.join(homeDir, ".exe-os");
+  const tokenPath = path.join(exeDir, "exed.token");
+  if (existsSync(tokenPath)) {
+    try {
+      const token2 = readFileSync(tokenPath, "utf-8").trim();
+      if (/^[a-f0-9]{64}$/i.test(token2)) return token2;
+    } catch {
+    }
+  }
+  const token = randomBytes(32).toString("hex");
+  mkdirSync(exeDir, { recursive: true });
+  writeFileSync(tokenPath, `${token}
+`, "utf-8");
+  try {
+    chmodSync(tokenPath, 384);
+  } catch {
+  }
+  return token;
+}
+function buildMcpHttpHeaders(homeDir = os.homedir(), opts = {}) {
+  const agentId = opts.useShellPlaceholders ? "${AGENT_ID:-exe}" : opts.agentId ?? DEFAULT_MCP_HTTP_AGENT_ID;
+  const agentRole = opts.useShellPlaceholders ? "${AGENT_ROLE:-COO}" : opts.agentRole ?? DEFAULT_MCP_HTTP_AGENT_ROLE;
+  let sessionName = process.env.EXE_SESSION_NAME ?? "";
+  if (!sessionName && !opts.useShellPlaceholders) {
+    try {
+      const tmuxSession = execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      if (tmuxSession) sessionName = tmuxSession;
+    } catch {
+    }
+  }
+  const headers = {
+    Authorization: `Bearer ${readOrCreateDaemonToken(homeDir)}`,
+    "X-Agent-Id": agentId,
+    "X-Agent-Role": agentRole
+  };
+  if (sessionName && !opts.useShellPlaceholders) headers["X-Exe-Session"] = sessionName;
+  return headers;
+}
+function buildClaudeHttpMcpEntry(homeDir = os.homedir()) {
+  const entry = {
+    type: "http",
+    url: mcpHttpUrl(),
+    headers: buildMcpHttpHeaders(homeDir, { useShellPlaceholders: true })
+  };
+  delete entry.headers["X-Exe-Session"];
+  return entry;
+}
+
+export {
+  DEFAULT_MCP_HTTP_PORT,
+  DEFAULT_MCP_HTTP_AGENT_ID,
+  DEFAULT_MCP_HTTP_AGENT_ROLE,
+  mcpHttpPort,
+  mcpHttpUrl,
+  readOrCreateDaemonToken,
+  buildMcpHttpHeaders,
+  buildClaudeHttpMcpEntry
+};

package/dist/chunk-FIPU4BDF.js

@@ -0,0 +1,123 @@
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/session-kill-telemetry.ts
+import crypto from "crypto";
+import { appendFileSync } from "fs";
+import path from "path";
+import os from "os";
+var KILL_FILE_LOG = path.join(os.homedir(), ".exe-os", "logs", "session-kills.jsonl");
+var TOKENS_PER_IDLE_MINUTE = 50;
+async function recordSessionKill(input) {
+  const killedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const id = crypto.randomUUID();
+  try {
+    const logEntry = JSON.stringify({
+      id,
+      timestamp: killedAt,
+      session: input.sessionName,
+      agent: input.agentId,
+      reason: input.reason,
+      ticksIdle: input.ticksIdle ?? null,
+      tokensSaved: input.estimatedTokensSaved ?? null
+    });
+    appendFileSync(KILL_FILE_LOG, logEntry + "\n");
+  } catch {
+    process.stderr.write(
+      `[session-kill-telemetry] file log write failed for ${input.sessionName}
+`
+    );
+  }
+  try {
+    const client = getClient();
+    await client.execute({
+      sql: `INSERT INTO session_kills
+              (id, session_name, agent_id, killed_at, reason,
+               ticks_idle, estimated_tokens_saved)
+            VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        input.sessionName,
+        input.agentId,
+        killedAt,
+        input.reason,
+        input.ticksIdle ?? null,
+        input.estimatedTokensSaved ?? null
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(
+      `[session-kill-telemetry] DB write failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function countKillsSince(sinceISO) {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) AS n FROM session_kills WHERE killed_at >= ?`,
+      args: [sinceISO]
+    });
+    const row = result.rows[0];
+    return row ? Number(row.n) : 0;
+  } catch {
+    return 0;
+  }
+}
+var IDLE_KILL_STREAK_META_KEY = "idle_kill_suspect_streak";
+var IDLE_KILL_SUSPECT_DAY_THRESHOLD = 3;
+var IDLE_KILL_MIN_LIVE_SESSIONS = 5;
+function parseStreakState(raw) {
+  if (!raw) return { lastDate: null, streak: 0 };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      lastDate: typeof parsed.lastDate === "string" ? parsed.lastDate : null,
+      streak: typeof parsed.streak === "number" ? parsed.streak : 0
+    };
+  } catch {
+    return { lastDate: null, streak: 0 };
+  }
+}
+function nextStreakState(prev, qualifiesToday, todayDate) {
+  if (!qualifiesToday) return { lastDate: todayDate, streak: 0 };
+  if (prev.lastDate === todayDate) return prev;
+  return { lastDate: todayDate, streak: prev.streak + 1 };
+}
+function computeIdleKillSuspectStreak(prev, killsToday, liveSessions, todayDate) {
+  const qualifies = killsToday === 0 && liveSessions >= IDLE_KILL_MIN_LIVE_SESSIONS;
+  const state = nextStreakState(prev, qualifies, todayDate);
+  return {
+    state,
+    suspect: state.streak >= IDLE_KILL_SUSPECT_DAY_THRESHOLD
+  };
+}
+async function sumTokensSavedSince(sinceISO) {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COALESCE(SUM(estimated_tokens_saved), 0) AS total
+            FROM session_kills
+            WHERE killed_at >= ?`,
+      args: [sinceISO]
+    });
+    const row = result.rows[0];
+    return row ? Number(row.total) : 0;
+  } catch {
+    return 0;
+  }
+}
+
+export {
+  TOKENS_PER_IDLE_MINUTE,
+  recordSessionKill,
+  countKillsSince,
+  IDLE_KILL_STREAK_META_KEY,
+  IDLE_KILL_SUSPECT_DAY_THRESHOLD,
+  IDLE_KILL_MIN_LIVE_SESSIONS,
+  parseStreakState,
+  computeIdleKillSuspectStreak,
+  sumTokensSavedSince
+};

package/dist/chunk-FLSASUV3.js

@@ -0,0 +1,177 @@
+// src/gateway/adapters/imessage.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import os from "os";
+import path from "path";
+var execFileAsync = promisify(execFile);
+var POLL_INTERVAL_MS = 5e3;
+var MESSAGES_DB_PATH = path.join(
+  process.env.HOME ?? os.homedir(),
+  "Library/Messages/chat.db"
+);
+var IMessageAdapter = class {
+  platform = "imessage";
+  messageHandler = null;
+  connected = false;
+  pollTimer = null;
+  lastMessageRowId = 0;
+  async connect(_config) {
+    if (process.platform !== "darwin") {
+      throw new Error("iMessage adapter is macOS only");
+    }
+    try {
+      await execFileAsync("osascript", [
+        "-e",
+        'tell application "Messages" to get name'
+      ]);
+    } catch (err) {
+      throw new Error(
+        `iMessage: cannot access Messages.app \u2014 grant Full Disk Access. ${err instanceof Error ? err.message : ""}`
+      );
+    }
+    try {
+      const { createClient } = await import("@libsql/client");
+      const db = createClient({ url: `file:${MESSAGES_DB_PATH}` });
+      const result = await db.execute("SELECT MAX(ROWID) as max_id FROM message");
+      this.lastMessageRowId = Number(result.rows[0]?.max_id) || 0;
+      db.close();
+    } catch {
+    }
+    this.connected = true;
+    console.log("[imessage] Connected via AppleScript bridge");
+    this.pollTimer = setInterval(() => {
+      void this.pollMessages();
+    }, POLL_INTERVAL_MS);
+  }
+  async disconnect() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async sendText(channelId, text, _options) {
+    if (!this.connected) throw new Error("iMessage not connected");
+    const sanitizeForAppleScript = (s) => s.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, "\\n");
+    const escapedText = sanitizeForAppleScript(text);
+    const escapedId = sanitizeForAppleScript(channelId);
+    if (!/^[+\d@.\w-]+$/.test(channelId)) {
+      throw new Error(`iMessage: invalid channelId format: ${channelId.slice(0, 50)}`);
+    }
+    const script = `
+      tell application "Messages"
+        set targetService to 1st service whose service type = iMessage
+        set targetBuddy to buddy "${escapedId}" of targetService
+        send "${escapedText}" to targetBuddy
+      end tell
+    `;
+    try {
+      await execFileAsync("osascript", ["-e", script]);
+    } catch (err) {
+      throw new Error(
+        `iMessage send failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async sendTyping(_channelId) {
+  }
+  async healthCheck() {
+    if (process.platform !== "darwin") return { connected: false };
+    const start = Date.now();
+    try {
+      await execFileAsync("osascript", [
+        "-e",
+        'tell application "Messages" to get name'
+      ]);
+      return { connected: true, latencyMs: Date.now() - start };
+    } catch {
+      return { connected: false };
+    }
+  }
+  /** Inject a message payload from webhook server */
+  async injectMessage(rawPayload) {
+    if (!this.messageHandler) return;
+    const msg = rawPayload;
+    if (msg.is_from_me) return;
+    const senderId = msg.handle_id ?? msg.sender ?? msg.from ?? "";
+    const isGroup = msg.is_group ?? !!msg.group_name;
+    const channelId = msg.chat_id != null ? String(msg.chat_id) : senderId;
+    const normalized = {
+      messageId: msg.guid ?? msg.id ?? String(Date.now()),
+      platform: "imessage",
+      senderId,
+      senderPhone: senderId.startsWith("+") ? senderId : void 0,
+      senderEmail: senderId.includes("@") ? senderId : void 0,
+      channelId,
+      chatType: isGroup ? "group" : "direct",
+      text: msg.text ?? "",
+      timestamp: msg.timestamp ? new Date(msg.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      raw: rawPayload
+    };
+    try {
+      await this.messageHandler(normalized);
+    } catch (err) {
+      console.error("[imessage] injectMessage handler error:", err);
+    }
+  }
+  async pollMessages() {
+    if (!this.messageHandler) return;
+    try {
+      const { createClient } = await import("@libsql/client");
+      const db = createClient({ url: `file:${MESSAGES_DB_PATH}` });
+      const result = await db.execute({
+        sql: `SELECT
+                m.ROWID, m.text, m.date, m.is_from_me,
+                h.id as handle_id, h.uncanonicalized_id,
+                c.chat_identifier, c.display_name
+              FROM message m
+              LEFT JOIN handle h ON m.handle_id = h.ROWID
+              LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
+              LEFT JOIN chat c ON cmj.chat_id = c.ROWID
+              WHERE m.ROWID > ? AND m.is_from_me = 0 AND m.text IS NOT NULL
+              ORDER BY m.ROWID ASC
+              LIMIT 50`,
+        args: [this.lastMessageRowId]
+      });
+      db.close();
+      for (const row of result.rows) {
+        const rowId = Number(row.ROWID);
+        if (rowId > this.lastMessageRowId) {
+          this.lastMessageRowId = rowId;
+        }
+        const macEpoch = (/* @__PURE__ */ new Date("2001-01-01T00:00:00Z")).getTime();
+        const timestamp = new Date(
+          macEpoch + Number(row.date) / 1e6
+        ).toISOString();
+        const senderId = row.handle_id ?? row.uncanonicalized_id ?? "";
+        const isGroup = (row.chat_identifier ?? "").includes(";");
+        const normalized = {
+          messageId: String(rowId),
+          platform: "imessage",
+          senderId,
+          senderPhone: senderId.startsWith("+") ? senderId : void 0,
+          senderEmail: senderId.includes("@") ? senderId : void 0,
+          channelId: row.chat_identifier ?? senderId,
+          chatType: isGroup ? "group" : "direct",
+          text: row.text ?? "",
+          timestamp,
+          raw: row
+        };
+        try {
+          await this.messageHandler(normalized);
+        } catch (err) {
+          console.error("[imessage] Message handler error:", err);
+        }
+      }
+    } catch (err) {
+      console.error("[imessage] Poll error:", err instanceof Error ? err.message : err);
+    }
+  }
+};
+
+export {
+  IMessageAdapter
+};

package/dist/chunk-FWFFZGSC.js

@@ -0,0 +1,94 @@
+// src/lib/providers/ollama.ts
+import { randomUUID } from "crypto";
+var OllamaProvider = class {
+  name;
+  defaultModel;
+  host;
+  constructor(name, config = {}) {
+    this.name = name;
+    this.host = (config.host ?? "http://localhost:11434").replace(/\/+$/, "");
+    this.defaultModel = config.defaultModel ?? "qwen3:14b";
+  }
+  async createMessage(params) {
+    const messages = [
+      { role: "system", content: params.system }
+    ];
+    for (const msg of params.messages) {
+      if (typeof msg.content === "string") {
+        messages.push({ role: msg.role, content: msg.content });
+      } else {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        messages.push({ role: msg.role, content: text });
+      }
+    }
+    const tools = params.tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }
+    }));
+    const body = {
+      model: params.model || this.defaultModel,
+      messages,
+      stream: false,
+      options: { num_predict: params.maxTokens }
+    };
+    if (tools?.length) body.tools = tools;
+    const res = await fetch(`${this.host}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      throw new Error(`Ollama API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    return this.normalizeResponse(data);
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const res = await fetch(`${this.host}/api/tags`, {
+        signal: AbortSignal.timeout(5e3)
+      });
+      return { available: res.ok, latencyMs: Date.now() - start };
+    } catch {
+      return { available: false };
+    }
+  }
+  normalizeResponse(data) {
+    const content = [];
+    if (data.message.content) {
+      content.push({ type: "text", text: data.message.content });
+    }
+    if (data.message.tool_calls) {
+      for (const call of data.message.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: randomUUID(),
+          name: call.function.name,
+          input: call.function.arguments
+        });
+      }
+    }
+    if (content.length === 0) {
+      content.push({ type: "text", text: "" });
+    }
+    const hasToolUse = content.some((b) => b.type === "tool_use");
+    return {
+      content,
+      stopReason: hasToolUse ? "tool_use" : "end_turn",
+      usage: {
+        inputTokens: data.prompt_eval_count ?? 0,
+        outputTokens: data.eval_count ?? 0
+      }
+    };
+  }
+};
+
+export {
+  OllamaProvider
+};

package/dist/chunk-FXU7JOXK.js

@@ -0,0 +1,6 @@
+// src/types/memory.ts
+var EMBEDDING_DIM = 1024;
+
+export {
+  EMBEDDING_DIM
+};

package/dist/chunk-G4LLKD4Z.js

@@ -0,0 +1,147 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-CTFKTUYN.js";
+
+// src/lib/session-registry.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import path from "path";
+import os from "os";
+var REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
+function registerSession(entry) {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const sessions = listSessions();
+  const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
+  if (idx >= 0) {
+    sessions[idx] = entry;
+  } else {
+    sessions.push(entry);
+  }
+  writeFileSync(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  recordOrchestrationEventBestEffort({
+    eventType: "registry.registered",
+    source: "session-registry.registerSession",
+    agentId: entry.agentId,
+    sessionScope: entry.parentExe,
+    tmuxSession: entry.windowName,
+    payload: { hasProjectDir: Boolean(entry.projectDir) }
+  });
+}
+function refreshSessionProject(windowName, projectDir) {
+  const sessions = listSessions();
+  const entry = sessions.find((s) => s.windowName === windowName);
+  if (!entry || entry.projectDir === projectDir) return;
+  entry.projectDir = projectDir;
+  try {
+    writeFileSync(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  } catch {
+  }
+}
+function listSessions() {
+  try {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function pruneStaleSessions() {
+  const sessions = listSessions();
+  if (sessions.length === 0) return 0;
+  let liveSessions = [];
+  try {
+    liveSessions = execSync("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+      encoding: "utf8"
+    }).trim().split("\n").filter(Boolean);
+  } catch {
+    return 0;
+  }
+  const liveSet = new Set(liveSessions);
+  const alive = sessions.filter((s) => liveSet.has(s.windowName));
+  const staleSessions = sessions.filter((s) => !liveSet.has(s.windowName));
+  if (staleSessions.length > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.pruneStaleSessions",
+      severity: "warn",
+      attempt: staleSessions.length,
+      payload: {
+        count: staleSessions.length,
+        examples: staleSessions.slice(0, 5).map((s) => s.windowName)
+      }
+    });
+  }
+  const pruned = sessions.length - alive.length;
+  if (pruned > 0) {
+    writeFileSync(REGISTRY_PATH, JSON.stringify(alive, null, 2));
+  }
+  return pruned;
+}
+function checkSessionRegistryConsistency(liveSessionsOverride) {
+  const sessions = listSessions();
+  const result = { missingTmux: 0, missingRegistry: 0 };
+  let liveSessions = liveSessionsOverride;
+  if (!liveSessions) {
+    try {
+      liveSessions = execSync("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+        encoding: "utf8"
+      }).trim().split("\n").filter(Boolean);
+    } catch {
+      return result;
+    }
+  }
+  const liveSet = new Set(liveSessions);
+  const registeredSet = new Set(sessions.map((s) => s.windowName));
+  const missingTmuxExamples = [];
+  const missingRegistryExamples = [];
+  for (const entry of sessions) {
+    if (liveSet.has(entry.windowName)) continue;
+    result.missingTmux++;
+    if (missingTmuxExamples.length < 5) missingTmuxExamples.push(entry.windowName);
+  }
+  for (const live of liveSessions) {
+    if (registeredSet.has(live)) continue;
+    if (!looksLikeExeOsSession(live)) continue;
+    result.missingRegistry++;
+    if (missingRegistryExamples.length < 5) missingRegistryExamples.push(live);
+  }
+  if (result.missingTmux > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_tmux",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingTmux,
+      payload: {
+        count: result.missingTmux,
+        examples: missingTmuxExamples
+      }
+    });
+  }
+  if (result.missingRegistry > 0) {
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.missing_entry",
+      source: "session-registry.checkSessionRegistryConsistency",
+      severity: "warn",
+      attempt: result.missingRegistry,
+      payload: {
+        count: result.missingRegistry,
+        examples: missingRegistryExamples
+      }
+    });
+  }
+  return result;
+}
+function looksLikeExeOsSession(sessionName) {
+  return /^exe\d*$/.test(sessionName) || /-exe\d*$/.test(sessionName);
+}
+
+export {
+  registerSession,
+  refreshSessionProject,
+  listSessions,
+  pruneStaleSessions,
+  checkSessionRegistryConsistency
+};