@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-HYKO2LNW.js

@@ -0,0 +1,157 @@
+import {
+  clean,
+  stableId
+} from "./chunk-SVUYBT5N.js";
+
+// src/lib/reflection-checkpoints.ts
+function parsePayload(payload) {
+  if (!payload) return {};
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return {};
+  }
+}
+function semanticArray(event, key) {
+  const payload = parsePayload(event.payload);
+  const semantic = payload.semantic;
+  const value = semantic?.[key];
+  return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function buildReflectionCheckpoint(events) {
+  if (!events.length) return null;
+  const sorted = [...events].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  const goals = /* @__PURE__ */ new Set();
+  const successes = [];
+  const failures = [];
+  const risks = [];
+  const nextActions = [];
+  const decisions = [];
+  for (const event of sorted) {
+    for (const goal of semanticArray(event, "goals")) goals.add(goal);
+    for (const item of semanticArray(event, "successSignals")) successes.push(item);
+    for (const item of semanticArray(event, "failureSignals")) failures.push(item);
+    for (const item of semanticArray(event, "nextActions")) nextActions.push(item);
+    for (const item of semanticArray(event, "decisions")) decisions.push(item);
+    if (event.impact === "negative" || event.outcome === "failure_signal" || event.event_type === "problem" || event.event_type === "error") {
+      failures.push(event.outcome || event.intention || event.event_type);
+    }
+    if (event.outcome === "risk_signal") risks.push(event.intention || event.outcome);
+    if (event.impact === "positive" || event.outcome === "success_signal" || event.event_type === "milestone") {
+      successes.push(event.outcome || event.intention || event.event_type);
+    }
+  }
+  const uniqueGoals = [...goals].slice(0, 6);
+  const uniqueSuccesses = [...new Set(successes.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueFailures = [...new Set(failures.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueRisks = [...new Set(risks.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueNext = [...new Set(nextActions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const uniqueDecisions = [...new Set(decisions.map((x) => clean(x, 180)).filter(Boolean))].slice(0, 6);
+  const learnings = [
+    uniqueSuccesses.length ? `Working: ${uniqueSuccesses.slice(0, 3).join("; ")}` : "Working: no strong success signal yet",
+    uniqueFailures.length ? `Improve: ${uniqueFailures.slice(0, 3).join("; ")}` : "Improve: no strong failure signal in this window",
+    uniqueDecisions.length ? `Decision context: ${uniqueDecisions.slice(0, 2).join("; ")}` : "Decision context: no explicit decision signal"
+  ];
+  const summary = clean([
+    `Window ${first.occurred_at} \u2192 ${last.occurred_at}`,
+    `${sorted.length} events`,
+    uniqueGoals.length ? `goals: ${uniqueGoals.join("; ")}` : "goals: inferred from event trajectory",
+    uniqueSuccesses.length ? `successes: ${uniqueSuccesses.slice(0, 2).join("; ")}` : "successes: none explicit",
+    uniqueFailures.length ? `failures: ${uniqueFailures.slice(0, 2).join("; ")}` : "failures: none explicit"
+  ].join(". "), 1200);
+  return {
+    id: stableId("reflection", first.project_name ?? "", first.session_id ?? "", first.occurred_at, last.occurred_at, sorted.length),
+    projectName: first.project_name ?? null,
+    sessionId: first.session_id ?? null,
+    windowStartAt: first.occurred_at,
+    windowEndAt: last.occurred_at,
+    eventCount: sorted.length,
+    goalCount: uniqueGoals.length,
+    successCount: uniqueSuccesses.length,
+    failureCount: uniqueFailures.length,
+    riskCount: uniqueRisks.length,
+    summary,
+    learnings,
+    nextActions: uniqueNext.length ? uniqueNext : ["Continue from latest successful event and resolve highest-impact failure/risk first."],
+    evidenceEventIds: sorted.slice(-25).map((e) => e.id),
+    confidence: Math.min(0.95, 0.5 + Math.min(sorted.length, 100) / 250 + uniqueGoals.length * 0.03)
+  };
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient } = await import("./lib/database.js");
+  return getClient();
+}
+async function insertReflectionCheckpoint(checkpoint, client) {
+  const db = await resolveClient(client);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_reflection_checkpoints
+      (id, project_name, session_id, window_start_at, window_end_at, event_count, goal_count,
+       success_count, failure_count, risk_count, summary, learnings, next_actions, evidence_event_ids,
+       confidence, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET summary = excluded.summary, learnings = excluded.learnings,
+        next_actions = excluded.next_actions, confidence = excluded.confidence`,
+    args: [
+      checkpoint.id,
+      checkpoint.projectName,
+      checkpoint.sessionId,
+      checkpoint.windowStartAt,
+      checkpoint.windowEndAt,
+      checkpoint.eventCount,
+      checkpoint.goalCount,
+      checkpoint.successCount,
+      checkpoint.failureCount,
+      checkpoint.riskCount,
+      checkpoint.summary,
+      JSON.stringify(checkpoint.learnings),
+      JSON.stringify(checkpoint.nextActions),
+      JSON.stringify(checkpoint.evidenceEventIds),
+      checkpoint.confidence,
+      now
+    ]
+  });
+}
+async function generateReflectionCheckpoints(opts = {}) {
+  const db = await resolveClient(opts.client);
+  const windowSize = opts.windowSize ?? 100;
+  const minEvents = opts.minEvents ?? 20;
+  const limit = opts.limit ?? 5e3;
+  const where = opts.projectName ? "WHERE project_name = ?" : "";
+  const args = opts.projectName ? [opts.projectName] : [];
+  const result = await db.execute({
+    sql: `SELECT id, event_type, occurred_at, actor_agent_id, project_name, session_id, intention, outcome, impact, evidence_memory_id, payload
+          FROM agent_events ${where}
+          ORDER BY project_name, session_id, occurred_at, sequence_index
+          LIMIT ?`,
+    args: [...args, limit]
+  });
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const event = row;
+    const key = `${event.project_name ?? ""}::${event.session_id ?? ""}`;
+    const bucket = groups.get(key) ?? [];
+    bucket.push(event);
+    groups.set(key, bucket);
+  }
+  let inserted = 0;
+  for (const events of groups.values()) {
+    for (let i = 0; i < events.length; i += windowSize) {
+      const window = events.slice(i, i + windowSize);
+      if (window.length < minEvents) continue;
+      const checkpoint = buildReflectionCheckpoint(window);
+      if (!checkpoint) continue;
+      await insertReflectionCheckpoint(checkpoint, db);
+      inserted++;
+    }
+  }
+  return inserted;
+}
+
+export {
+  buildReflectionCheckpoint,
+  generateReflectionCheckpoints
+};

package/dist/chunk-IFL6DG2K.js

@@ -0,0 +1,181 @@
+import {
+  getClient
+} from "./chunk-XABJRAUW.js";
+import {
+  loadConfig
+} from "./chunk-R36FAN53.js";
+
+// src/lib/reminders.ts
+import crypto from "crypto";
+async function getCloudConfig() {
+  try {
+    const config = await loadConfig();
+    if (config.cloud?.apiKey && config.cloud?.endpoint) {
+      return { apiKey: config.cloud.apiKey, endpoint: config.cloud.endpoint };
+    }
+  } catch {
+  }
+  return null;
+}
+function apiBaseUrl(cloud) {
+  try {
+    const url = new URL(cloud.endpoint);
+    if (url.hostname.startsWith("sync.")) {
+      url.hostname = url.hostname.replace(/^sync\./, "api.");
+      return url.origin;
+    }
+  } catch {
+  }
+  return "https://api.askexe.com";
+}
+async function cloudPushReminder(cloud, text, dueDate) {
+  try {
+    const base = apiBaseUrl(cloud);
+    await fetch(`${base}/v1/reminders`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text, due_date: dueDate })
+    });
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud push failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+async function cloudFetchReminders(cloud) {
+  try {
+    const base = apiBaseUrl(cloud);
+    const res = await fetch(`${base}/v1/reminders`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`
+      }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    if (!Array.isArray(data.items)) return [];
+    return data.items.map((r) => ({
+      id: r.id,
+      text: r.text,
+      createdAt: r.created_at,
+      dueDate: r.due_date,
+      completedAt: r.completed_at,
+      source: "cloud"
+    }));
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud fetch failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return [];
+  }
+}
+async function cloudDeleteReminder(cloud, id) {
+  try {
+    const base = apiBaseUrl(cloud);
+    await fetch(`${base}/v1/reminders/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${cloud.apiKey}`
+      }
+    });
+  } catch (err) {
+    process.stderr.write(`[reminders] cloud delete failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function dedup(local, cloud) {
+  const localKeys = /* @__PURE__ */ new Set();
+  for (const r of local) {
+    localKeys.add(`${r.text.trim().toLowerCase()}|${r.dueDate ?? ""}`);
+  }
+  const merged = local.map((r) => ({ ...r, source: "local" }));
+  for (const r of cloud) {
+    const key = `${r.text.trim().toLowerCase()}|${r.dueDate ?? ""}`;
+    if (localKeys.has(key)) {
+      const existing = merged.find(
+        (m) => m.text.trim().toLowerCase() === r.text.trim().toLowerCase() && (m.dueDate ?? "") === (r.dueDate ?? "")
+      );
+      if (existing) existing.source = "both";
+    } else {
+      merged.push({ ...r, source: "cloud" });
+    }
+  }
+  return merged;
+}
+async function createReminder(text, dueDate) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    sql: `INSERT INTO reminders (id, text, created_at, due_date) VALUES (?, ?, ?, ?)`,
+    args: [id, text, now, dueDate ?? null]
+  });
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    cloudPushReminder(cloud, text, dueDate ?? null).catch(() => {
+    });
+  }
+  return { id, text, createdAt: now, dueDate: dueDate ?? null, completedAt: null };
+}
+async function listReminders(includeCompleted = false) {
+  const client = getClient();
+  const sql = includeCompleted ? `SELECT id, text, created_at, due_date, completed_at FROM reminders ORDER BY due_date ASC NULLS LAST LIMIT 500` : `SELECT id, text, created_at, due_date, completed_at FROM reminders WHERE completed_at IS NULL ORDER BY due_date ASC NULLS LAST LIMIT 500`;
+  const result = await client.execute(sql);
+  const local = result.rows.map((row) => ({
+    id: String(row.id),
+    text: String(row.text),
+    createdAt: String(row.created_at),
+    dueDate: row.due_date ? String(row.due_date) : null,
+    completedAt: row.completed_at ? String(row.completed_at) : null
+  }));
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    const cloudReminders = await cloudFetchReminders(cloud);
+    return dedup(local, cloudReminders);
+  }
+  return local;
+}
+async function completeReminder(idOrText) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let result = await client.execute({
+    sql: `SELECT id, text FROM reminders WHERE id = ? AND completed_at IS NULL`,
+    args: [idOrText]
+  });
+  if (result.rows.length === 0) {
+    result = await client.execute({
+      sql: `SELECT id, text FROM reminders WHERE completed_at IS NULL AND text LIKE '%' || ? || '%' LIMIT 1`,
+      args: [idOrText]
+    });
+  }
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  const id = String(row.id);
+  const text = String(row.text);
+  await client.execute({
+    sql: `UPDATE reminders SET completed_at = ? WHERE id = ?`,
+    args: [now, id]
+  });
+  const cloud = await getCloudConfig();
+  if (cloud) {
+    cloudDeleteReminder(cloud, id).catch(() => {
+    });
+    cloudFetchReminders(cloud).then((cloudReminders) => {
+      for (const cr of cloudReminders) {
+        if (cr.text.trim().toLowerCase() === text.trim().toLowerCase()) {
+          cloudDeleteReminder(cloud, cr.id).catch(() => {
+          });
+        }
+      }
+    }).catch(() => {
+    });
+  }
+  return { id, text, createdAt: "", dueDate: null, completedAt: now };
+}
+
+export {
+  createReminder,
+  listReminders,
+  completeReminder
+};

package/dist/chunk-IKPQRHVQ.js

@@ -0,0 +1,304 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-RCGHXBCX.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/session-registry.ts
+import { readFileSync, mkdirSync, existsSync, openSync, closeSync, writeSync, unlinkSync, constants } from "fs";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
+var REGISTRY_LOCK_PATH = `${REGISTRY_PATH}.lock`;
+var REGISTRY_CACHE_TTL_MS = 100;
+var registryCache = null;
+function acquireRegistryLock() {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const data = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const deadline = Date.now() + 250;
+  while (Date.now() < deadline) {
+    try {
+      const fd = openSync(REGISTRY_LOCK_PATH, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+      writeSync(fd, data);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const lock = JSON.parse(readFileSync(REGISTRY_LOCK_PATH, "utf8"));
+        if (Date.now() - Number(lock.timestamp ?? 0) > 3e4) unlinkSync(REGISTRY_LOCK_PATH);
+      } catch {
+        try {
+          unlinkSync(REGISTRY_LOCK_PATH);
+        } catch {
+        }
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  return false;
+}
+function releaseRegistryLock() {
+  try {
+    unlinkSync(REGISTRY_LOCK_PATH);
+  } catch {
+  }
+}
+function readSessionsUncached() {
+  try {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writeSessions(sessions) {
+  atomicWriteJsonSync(REGISTRY_PATH, sessions);
+  registryCache = { at: Date.now(), sessions };
+}
+function registerSession(entry) {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const _locked = acquireRegistryLock();
+  try {
+    const sessions = readSessionsUncached();
+    const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
+    if (idx >= 0) {
+      sessions[idx] = entry;
+    } else {
+      sessions.push(entry);
+    }
+    writeSessions(sessions);
+  } finally {
+    if (_locked) releaseRegistryLock();
+  }
+  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) {
+  if (!acquireRegistryLock()) return;
+  try {
+    const sessions = readSessionsUncached();
+    const entry = sessions.find((s) => s.windowName === windowName);
+    if (!entry || entry.projectDir === projectDir) return;
+    entry.projectDir = projectDir;
+    writeSessions(sessions);
+  } catch {
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function listSessions() {
+  const now = Date.now();
+  if (registryCache && now - registryCache.at < REGISTRY_CACHE_TTL_MS) {
+    return registryCache.sessions;
+  }
+  const sessions = readSessionsUncached();
+  registryCache = { at: now, sessions };
+  return sessions;
+}
+function pruneStaleSessions() {
+  if (!acquireRegistryLock()) return 0;
+  const sessions = readSessionsUncached();
+  if (sessions.length === 0) {
+    releaseRegistryLock();
+    return 0;
+  }
+  let liveSessions = [];
+  try {
+    liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim().split("\n").filter(Boolean);
+  } catch {
+    releaseRegistryLock();
+    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) {
+    writeSessions(alive);
+  }
+  releaseRegistryLock();
+  return pruned;
+}
+function checkSessionRegistryConsistency(liveSessionsOverride) {
+  const sessions = listSessions();
+  const result = { missingTmux: 0, missingRegistry: 0 };
+  let liveSessions = liveSessionsOverride;
+  if (!liveSessions) {
+    try {
+      liveSessions = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).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 deregisterSession(windowName) {
+  if (!acquireRegistryLock()) return null;
+  try {
+    const sessions = readSessionsUncached();
+    const idx = sessions.findIndex((s) => s.windowName === windowName);
+    if (idx < 0) return null;
+    const removed = sessions.splice(idx, 1)[0];
+    writeSessions(sessions);
+    recordOrchestrationEventBestEffort({
+      eventType: "registry.deregistered",
+      source: "session-registry.deregisterSession",
+      agentId: removed.agentId,
+      sessionScope: removed.parentExe,
+      tmuxSession: windowName,
+      payload: { reason: "admin_force_deregister" }
+    });
+    return removed;
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function cleanupDeadSessions(liveTmuxOverride) {
+  if (!acquireRegistryLock()) return { pruned: 0, remaining: 0, removed: [] };
+  try {
+    const sessions = readSessionsUncached();
+    if (sessions.length === 0) return { pruned: 0, remaining: 0, removed: [] };
+    let liveTmux;
+    if (liveTmuxOverride) {
+      if (liveTmuxOverride.length === 0) return { pruned: 0, remaining: sessions.length, removed: [] };
+      liveTmux = new Set(liveTmuxOverride.filter(Boolean));
+    } else {
+      try {
+        const raw = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        liveTmux = new Set(raw.split("\n").filter(Boolean));
+      } catch {
+        liveTmux = /* @__PURE__ */ new Set();
+      }
+    }
+    const alive = [];
+    const removed = [];
+    for (const s of sessions) {
+      const tmuxAlive = liveTmux.has(s.windowName);
+      let pidAlive = false;
+      try {
+        process.kill(s.pid, 0);
+        pidAlive = true;
+      } catch {
+      }
+      if (tmuxAlive || pidAlive) {
+        alive.push(s);
+      } else {
+        removed.push(s.windowName);
+      }
+    }
+    if (removed.length > 0) {
+      writeSessions(alive);
+      recordOrchestrationEventBestEffort({
+        eventType: "registry.cleanup",
+        source: "session-registry.cleanupDeadSessions",
+        severity: "info",
+        payload: { pruned: removed.length, remaining: alive.length, examples: removed.slice(0, 10) }
+      });
+    }
+    return { pruned: removed.length, remaining: alive.length, removed };
+  } finally {
+    releaseRegistryLock();
+  }
+}
+function looksLikeExeOsSession(sessionName) {
+  const coordName = getCoordinatorNameCached();
+  const escaped = coordName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const coordPattern = new RegExp(`^${escaped}\\d*$`);
+  const employeePattern = new RegExp(`-${escaped}\\d*$`);
+  return coordPattern.test(sessionName) || employeePattern.test(sessionName);
+}
+function getCoordinatorNameCached() {
+  try {
+    const rosterPath = path.join(os.homedir(), ".exe-os", "exe-employees.json");
+    if (existsSync(rosterPath)) {
+      const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+      const coo = roster.find((e) => (e.role ?? "").toUpperCase() === "COO");
+      if (coo?.name) return coo.name;
+    }
+  } catch {
+  }
+  return "exe";
+}
+
+export {
+  registerSession,
+  refreshSessionProject,
+  listSessions,
+  pruneStaleSessions,
+  checkSessionRegistryConsistency,
+  deregisterSession,
+  cleanupDeadSessions
+};