@askexenow/exe-os 0.9.203 → 0.9.205

package/dist/{chunk-HXYL4QX6.js → chunk-EUMLEWXO.js}

@@ -1,13 +1,13 @@
 import {
   vectorToBlob
-} from "./chunk-QLKRYO7O.js";
+} from "./chunk-TCBUBBTL.js";
 import {
   extractKeywords,
   keywordsToString
 } from "./chunk-CHCA3ZM2.js";
 import {
   isCoordinatorName
-} from "./chunk-K3O4MWMS.js";
+} from "./chunk-3MHKTBHZ.js";
 
 // src/lib/consolidation.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-RJCZY4BY.js → chunk-FMKD6N33.js}

@@ -1,12 +1,12 @@
 import {
   ensureWorktree
-} from "./chunk-RN6XYY7U.js";
+} from "./chunk-FYJCMGTD.js";
 import {
   queueIntercom
 } from "./chunk-QI4IXJN7.js";
 import {
   registerSession
-} from "./chunk-64WZEXXA.js";
+} from "./chunk-IR4L6K5L.js";
 import {
   getTransport
 } from "./chunk-5YDHBZCO.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-GZIAQYGI.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-ZGQH3V2F.js";
+} from "./chunk-ITYWLFYC.js";
 import {
   DEFAULT_PROVIDER,
   PROVIDER_TABLE,
@@ -33,7 +33,7 @@ import {
 import {
   PlanLimitError,
   assertEmployeeLimitSync
-} from "./chunk-SN6Z3CBF.js";
+} from "./chunk-3PDZQICZ.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
@@ -48,7 +48,7 @@ import {
 } from "./chunk-MP2AFCGL.js";
 import {
   ensureAgentSymlink
-} from "./chunk-HXNTQP4B.js";
+} from "./chunk-RN6DEMC7.js";
 import {
   expandDualPrefixTools
 } from "./chunk-HYZV25LY.js";
@@ -60,7 +60,7 @@ import {
   isCoordinatorName,
   loadEmployees,
   loadEmployeesSync
-} from "./chunk-K3O4MWMS.js";
+} from "./chunk-3MHKTBHZ.js";
 import {
   loadDeviceId
 } from "./chunk-72DJ42IE.js";
@@ -374,7 +374,7 @@ async function createTaskCore(input) {
       if (isCoordinatorSession) {
         earlySessionScope = resolved;
       } else {
-        const { getSessionProject } = await import("./session-scope-UJI35BLD.js");
+        const { getSessionProject } = await import("./session-scope-7BZTNB2X.js");
         const sessionProject = getSessionProject(resolved);
         if (sessionProject && sessionProject !== input.projectName) {
           scopeMismatchWarning = `session/project mismatch: session "${resolved}" owns "${sessionProject}" but task targets "${input.projectName}". Routed to default scope.`;
@@ -823,7 +823,7 @@ async function updateTaskStatus(input) {
     } catch {
     }
     try {
-      const { writeNotification: writeNotification2 } = await import("./notifications-GHNYYITD.js");
+      const { writeNotification: writeNotification2 } = await import("./notifications-6GRSVIP6.js");
       await writeNotification2({
         agentId: reviewer,
         agentRole: isCoordinatorName(reviewer) ? "COO" : "manager",
@@ -1146,13 +1146,36 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
       projectName: eventProjectName
     });
   }
+  if (input.status === "closed" && previousStatus === "needs_review") {
+    recordOrchestrationEventBestEffort({
+      eventType: "review.approved",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName
+    });
+  }
+  if (previousStatus === "needs_review" && (input.status === "open" || input.status === "in_progress")) {
+    recordOrchestrationEventBestEffort({
+      eventType: "review.rejected",
+      source: "tasks-crud.updateTaskStatus",
+      taskId,
+      agentId: eventAgentId,
+      reviewer: row.reviewer ? String(row.reviewer) : null,
+      sessionScope: eventSessionScope,
+      projectName: eventProjectName,
+      result: input.status
+    });
+  }
   try {
     await client.execute("PRAGMA wal_checkpoint(PASSIVE)");
   } catch {
   }
   if (input.status === "done" || input.status === "needs_review") {
     try {
-      const { incrementSkillSuccess } = await import("./skill-refinement-WZL35CMY.js");
+      const { incrementSkillSuccess } = await import("./skill-refinement-7C7X42Z5.js");
       await incrementSkillSuccess(
         String(row.assigned_to),
         row.project_name ? String(row.project_name) : null
@@ -1272,6 +1295,15 @@ async function cleanOrphanedTaskFiles() {
               if (ageMs > 24 * 60 * 60 * 1e3) {
                 await unlink(fullPath);
                 cleaned++;
+                recordOrchestrationEventBestEffort({
+                  eventType: "task_file.orphan_cleaned",
+                  source: "tasks-crud.cleanOrphanedTaskFiles",
+                  severity: "warn",
+                  payload: {
+                    ageHours: Math.round(ageMs / 36e5),
+                    type: "task_file_missing_db"
+                  }
+                });
                 process.stderr.write(`[task-cleanup] Removed orphan task file: ${relativePath}
 `);
               }
@@ -1285,6 +1317,39 @@ async function cleanOrphanedTaskFiles() {
   await walkDir(EXE_TASKS_DIR);
   return cleaned;
 }
+async function checkTaskFileConsistency() {
+  const client = getClient();
+  let mismatches = 0;
+  try {
+    const result = await client.execute({
+      sql: `SELECT id, title, task_file, status, assigned_to, session_scope, project_name
+            FROM tasks
+            WHERE status IN ('open', 'in_progress', 'needs_review', 'blocked')
+              AND task_file IS NOT NULL AND task_file != ''`,
+      args: []
+    });
+    for (const row of result.rows) {
+      const taskFile = String(row.task_file ?? "");
+      if (!taskFile) continue;
+      const fullPath = taskFile.startsWith("/") ? taskFile : path2.join(os2.homedir(), ".exe-os", taskFile);
+      if (!existsSync2(fullPath)) {
+        mismatches++;
+        recordOrchestrationEventBestEffort({
+          eventType: "consistency.mismatch",
+          source: "tasks-crud.checkTaskFileConsistency",
+          severity: "warn",
+          taskId: String(row.id),
+          agentId: row.assigned_to ? String(row.assigned_to) : null,
+          sessionScope: row.session_scope ? String(row.session_scope) : null,
+          projectName: row.project_name ? String(row.project_name) : null,
+          payload: { taskFile, status: String(row.status), type: "db_row_missing_file" }
+        });
+      }
+    }
+  } catch {
+  }
+  return mismatches;
+}
 
 // src/lib/notifications.ts
 import crypto2 from "crypto";
@@ -2239,7 +2304,7 @@ async function verifyPaneAtCapacity(sessionName) {
       reason: `capture-pane failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const { isAtCapacity } = await import("./capacity-monitor-TGSIL7W4.js");
+  const { isAtCapacity } = await import("./capacity-monitor-EPHJTSKF.js");
   if (!isAtCapacity(pane)) {
     return {
       atCapacity: false,
@@ -2576,6 +2641,16 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
       };
     }
     effectiveInstance = free === 0 ? void 0 : free;
+    if (free !== null) {
+      recordOrchestrationEventBestEffort({
+        eventType: "worker.instance.selected",
+        source: "tmux-routing.ensureEmployee",
+        agentId: employeeName,
+        sessionScope: exeSession,
+        instanceId: String(free),
+        payload: { maxInstances: opts.maxAutoInstances ?? 10 }
+      });
+    }
   }
   const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
   if (isEmployeeAlive(sessionName)) {
@@ -3023,6 +3098,7 @@ export {
   ensureArchitectureDoc,
   ensureGitignoreExe,
   cleanOrphanedTaskFiles,
+  checkTaskFileConsistency,
   formatAge,
   isStale,
   countPendingReviews,

package/dist/{chunk-RN6XYY7U.js → chunk-FYJCMGTD.js}

@@ -1,3 +1,7 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-ITYWLFYC.js";
+
 // src/lib/worktree.ts
 import { execSync } from "child_process";
 import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
@@ -48,6 +52,13 @@ function ensureWorktree(projectDir, employeeName, instance) {
   const wtPath = worktreePath(repoRoot, employeeName, instance);
   const branch = worktreeBranch(employeeName, instance);
   if (existsSync(path.join(wtPath, ".git"))) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
     return wtPath;
   }
   const worktreesDir = path.join(repoRoot, ".worktrees");
@@ -79,8 +90,24 @@ function ensureWorktree(projectDir, employeeName, instance) {
         stdio: ["pipe", "pipe", "pipe"]
       });
     }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
     return wtPath;
   } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
     process.stderr.write(
       `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
 `
@@ -107,16 +134,44 @@ function cleanupWorktree(projectDir, employeeName, instance) {
   const wtPath = worktreePath(repoRoot, employeeName, instance);
   const branch = worktreeBranch(employeeName, instance);
   if (!existsSync(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree does not exist", branch }
+    });
     return { cleaned: false, reason: "worktree does not exist" };
   }
   if (isWorktreeDirty(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree has uncommitted changes", branch }
+    });
     return { cleaned: false, reason: "worktree has uncommitted changes" };
   }
   const mainBranch = detectMainBranch(repoRoot);
   if (!mainBranch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "could not determine main branch", branch }
+    });
     return { cleaned: false, reason: "could not determine main branch" };
   }
   if (!isBranchMerged(repoRoot, branch, mainBranch)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "branch not merged", branch, mainBranch }
+    });
     return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
   }
   try {
@@ -127,6 +182,15 @@ function cleanupWorktree(projectDir, employeeName, instance) {
       stdio: ["pipe", "pipe", "pipe"]
     });
   } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.cleanupWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_remove_failed",
+      payload: { branch, mainBranch }
+    });
     return {
       cleaned: false,
       reason: `git worktree remove failed: ${err instanceof Error ? err.message : String(err)}`
@@ -141,6 +205,13 @@ function cleanupWorktree(projectDir, employeeName, instance) {
     });
   } catch {
   }
+  recordOrchestrationEventBestEffort({
+    eventType: "worktree.pruned",
+    source: "worktree.cleanupWorktree",
+    agentId: employeeName,
+    instanceId: instance != null ? String(instance) : null,
+    payload: { branch, mainBranch }
+  });
   return { cleaned: true, reason: `worktree and branch ${branch} removed (merged into ${mainBranch})` };
 }
 function branchExistsLocally(repoRoot, branch) {

package/dist/{chunk-USQF2GGF.js → chunk-H7U7FPQF.js}

@@ -3,30 +3,44 @@ import {
 } from "./chunk-MLXJ5EZG.js";
 import {
   createTask
-} from "./chunk-WGMHQVGX.js";
+} from "./chunk-O2JGR7EU.js";
 import {
   getActiveAgent
-} from "./chunk-UY6RQK5F.js";
+} from "./chunk-3N4ZEPZI.js";
 import {
   ensureEmployee,
   logTaskDispatch,
   resolveExeSession
-} from "./chunk-RJCZY4BY.js";
+} from "./chunk-FMKD6N33.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-ITYWLFYC.js";
+import {
+  getAgentRuntime
+} from "./chunk-6RX2XEET.js";
 import {
   getLicenseSync
-} from "./chunk-SN6Z3CBF.js";
+} from "./chunk-3PDZQICZ.js";
 import {
   getAgentContext
 } from "./chunk-GJV3WDWM.js";
 import {
   isCoordinatorName
-} from "./chunk-K3O4MWMS.js";
+} from "./chunk-3MHKTBHZ.js";
 
 // src/mcp/tools/create-task.ts
 import { z } from "zod";
 import { existsSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+function resolveDispatchRuntime(agentId, override) {
+  if (override) return override;
+  try {
+    return getAgentRuntime(agentId).runtime ?? null;
+  } catch {
+    return null;
+  }
+}
 async function resolveProjectDir(projectName, callerSession) {
   const home = homedir();
   if (callerSession) {
@@ -197,19 +211,39 @@ function registerCreateTask(server) {
           session_scope: sessionScope,
           created_at: (/* @__PURE__ */ new Date()).toISOString()
         }), "utf-8");
+        const { recordOrchestrationEventBestEffort: recordOE } = await import("./orchestration-events-MSJVUR4T.js");
+        recordOE({
+          eventType: "signal.created",
+          source: "create-task.mcp",
+          taskId: task.id,
+          agentId: assigned_to,
+          sessionScope,
+          payload: { priority }
+        });
       } catch {
       }
       let dispatchStatus = "";
       if (task.status !== "blocked" && !process.env.VITEST) {
         try {
           const exeSession = callerRoot || resolveExeSession();
+          const dispatchRuntime = resolveDispatchRuntime(assigned_to, spawn_runtime ?? null);
+          recordOrchestrationEventBestEffort({
+            eventType: "dispatch.attempted",
+            source: "create-task.mcp",
+            taskId: task.id,
+            agentId: assigned_to,
+            sessionScope: task.sessionScope || callerRoot || exeSession || null,
+            projectName: project_name,
+            runtime: dispatchRuntime,
+            payload: { priority }
+          });
           if (exeSession) {
             const { shouldAutoInstance } = await import("./lib/employees.js");
             const autoOpts = shouldAutoInstance(assigned_to);
             let projectConflictOpts = {};
             try {
               const { getClient } = await import("./lib/database.js");
-              const { sessionScopeFilter } = await import("./task-scope-EYAOY6YX.js");
+              const { sessionScopeFilter } = await import("./task-scope-ULC62J6G.js");
               const client = getClient();
               const scope = sessionScopeFilter();
               const existing = await client.execute({
@@ -243,6 +277,10 @@ function registerCreateTask(server) {
                 dispatchStatus = `
 Dispatched: intercom sent to ${result.sessionName}`;
                 break;
+              case "intercom_unprocessed":
+                dispatchStatus = `
+Dispatched: intercom delivered to ${result.sessionName}`;
+                break;
               case "spawned":
                 dispatchStatus = `
 Dispatched: spawned ${result.sessionName}`;
@@ -252,6 +290,20 @@ Dispatched: spawned ${result.sessionName}`;
 Dispatch failed: ${result.error ?? "unknown"}`;
                 break;
             }
+            recordOrchestrationEventBestEffort({
+              eventType: result.status === "failed" ? "dispatch.failed" : "dispatch.completed",
+              source: "create-task.mcp",
+              severity: result.status === "failed" ? "warn" : "info",
+              taskId: task.id,
+              agentId: assigned_to,
+              sessionScope: task.sessionScope || callerRoot || exeSession,
+              projectName: project_name,
+              tmuxSession: result.sessionName || null,
+              runtime: dispatchRuntime,
+              result: result.status,
+              errorCode: result.status === "failed" ? "ensure_employee_failed" : null,
+              payload: { priority, error: result.error ?? null }
+            });
             try {
               const { sendIntercom: si } = await import("./lib/tmux-routing.js");
               const { listTmuxSessions } = await import("./lib/tmux-status.js");
@@ -287,8 +339,32 @@ Dispatch failed: ${result.error ?? "unknown"}`;
               sessionName: result.sessionName,
               error: result.error
             });
+          } else {
+            recordOrchestrationEventBestEffort({
+              eventType: "dispatch.failed",
+              source: "create-task.mcp",
+              severity: "warn",
+              taskId: task.id,
+              agentId: assigned_to,
+              sessionScope: task.sessionScope || callerRoot || null,
+              projectName: project_name,
+              runtime: dispatchRuntime,
+              errorCode: "no_exe_session",
+              payload: { priority }
+            });
           }
         } catch (dispatchErr) {
+          recordOrchestrationEventBestEffort({
+            eventType: "dispatch.failed",
+            source: "create-task.mcp",
+            severity: "warn",
+            taskId: task.id,
+            agentId: assigned_to,
+            sessionScope: task.sessionScope || callerRoot || null,
+            projectName: project_name,
+            runtime: resolveDispatchRuntime(assigned_to, spawn_runtime ?? null),
+            errorCode: "exception"
+          });
           process.stderr.write(`[create-task] dispatch error for ${assigned_to}: ${dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)}
 ${dispatchErr instanceof Error ? dispatchErr.stack : ""}
 `);

package/dist/{chunk-FMI7SCZJ.js → chunk-HLYNKMAG.js}

@@ -1,6 +1,6 @@
 import {
   processCRMEvent
-} from "./chunk-QQN7MHQG.js";
+} from "./chunk-ONCFSN5C.js";
 
 // src/gateway/adapters/crm-webhook.ts
 function parseTwentyWebhook(payload) {

package/dist/{chunk-BGOQFJ2H.js → chunk-HMGIQNME.js}

@@ -1,9 +1,9 @@
 import {
   fastDbInit
-} from "./chunk-L63IOJ5N.js";
+} from "./chunk-2THPPZF2.js";
 import {
   sessionScopeFilter
-} from "./chunk-RJCZY4BY.js";
+} from "./chunk-FMKD6N33.js";
 import {
   formatStatusAll,
   formatStatusDeep,
@@ -14,7 +14,7 @@ import {
   getClient,
   isCoordinatorRole,
   loadEmployees
-} from "./chunk-K3O4MWMS.js";
+} from "./chunk-3MHKTBHZ.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/chunk-IR4L6K5L.js

@@ -0,0 +1,147 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-ITYWLFYC.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
+};