@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/bin/exe-boot.js

@@ -0,0 +1,1114 @@
+#!/usr/bin/env node
+import {
+  generateStatusBrief
+} from "../chunk-LWVZLTMD.js";
+import {
+  DEFAULT_EXE,
+  getSessionPrompt
+} from "../chunk-ADJXHBEU.js";
+import "../chunk-OHPRXEUA.js";
+import "../chunk-5NFBE376.js";
+import {
+  initStore
+} from "../chunk-HTCBLSIB.js";
+import "../chunk-CHCA3ZM2.js";
+import "../chunk-IW53DAYO.js";
+import {
+  cleanupSessionMarkers,
+  writeActiveAgent
+} from "../chunk-DLXTKVBO.js";
+import "../chunk-F7LU65PQ.js";
+import {
+  cleanupOldNotifications,
+  getMySession,
+  markAsRead,
+  markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications,
+  readUnreadNotifications,
+  resolveExeSession,
+  sessionScopeFilter,
+  updateTaskStatus
+} from "../chunk-UBMGUX6T.js";
+import "../chunk-I2CDSGQW.js";
+import "../chunk-QI4IXJN7.js";
+import "../chunk-4JERP7NT.js";
+import {
+  pruneStaleSessions,
+  registerSession
+} from "../chunk-G4LLKD4Z.js";
+import "../chunk-MVW62NIZ.js";
+import "../chunk-OYNKIAVW.js";
+import "../chunk-CX6GL3ZJ.js";
+import "../chunk-CTFKTUYN.js";
+import "../chunk-GVP5U4WL.js";
+import "../chunk-NGP6LSV2.js";
+import "../chunk-V3QAAU2U.js";
+import "../chunk-CVYC6DUW.js";
+import "../chunk-OPU3NYOO.js";
+import "../chunk-GJV3WDWM.js";
+import "../chunk-MP2AFCGL.js";
+import "../chunk-RMPAMMYW.js";
+import "../chunk-HYZV25LY.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getClient,
+  getCoordinatorEmployee,
+  isCoordinatorName,
+  loadEmployees,
+  saveEmployees
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-7NNXBDOO.js";
+import "../chunk-D4IVTUNN.js";
+import {
+  EXE_AI_DIR,
+  loadConfig,
+  loadConfigSync
+} from "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import {
+  isMainModule
+} from "../chunk-6Y4B3QF6.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/exe-boot.ts
+import path from "path";
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "fs";
+import { execSync } from "child_process";
+import os from "os";
+async function boot(options) {
+  const briefOnly = options?.briefOnly ?? false;
+  let employees = await loadEmployees();
+  if (employees.length === 0) {
+    employees = [DEFAULT_EXE];
+    await saveEmployees(employees);
+  }
+  const coordinatorEmployee = getCoordinatorEmployee(employees) ?? DEFAULT_EXE;
+  const coordinatorName = coordinatorEmployee.name;
+  await initStore();
+  cleanupSessionMarkers();
+  writeActiveAgent(coordinatorName, coordinatorEmployee.role);
+  let licensePlan;
+  let employeeLimit;
+  try {
+    const { checkLicense, loadLicense } = await import("../lib/license.js");
+    const hasKey = !!loadLicense();
+    if (hasKey) {
+      const license = await checkLicense();
+      licensePlan = license.plan;
+      employeeLimit = license.employeeLimit;
+      if (!license.valid) {
+        process.stderr.write(
+          "\u26A0 License key present but not valid. Check plan status at https://askexe.com.\n"
+        );
+      }
+    } else {
+      licensePlan = "free";
+      employeeLimit = 1;
+    }
+  } catch {
+  }
+  try {
+    const exeWindow = getMySession();
+    if (exeWindow) {
+      registerSession({
+        windowName: exeWindow,
+        agentId: coordinatorName,
+        projectDir: process.cwd(),
+        parentExe: null,
+        pid: process.ppid,
+        registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    pruneStaleSessions();
+  } catch {
+  }
+  const client = getClient();
+  const briefData = {
+    pendingReviews: [],
+    globalTasks: [],
+    flaggedIssues: [],
+    completedSinceLastBoot: [],
+    workload: [],
+    velocity: [],
+    activeProjects: [],
+    cloudConnected: false,
+    exeSession: resolveExeSession() ?? void 0,
+    plan: licensePlan,
+    employeeLimit
+  };
+  try {
+    const config = await loadConfig();
+    briefData.orchestrationPhase = config.orchestration?.phase;
+  } catch {
+    briefData.orchestrationPhase = "phase_1_coo";
+  }
+  if (!briefOnly) {
+    await migrateJsonNotifications();
+    await markDoneTaskNotificationsAsRead(briefData.exeSession);
+    try {
+      const orphanScope = sessionScopeFilter();
+      await client.execute({
+        sql: `DELETE FROM notifications
+            WHERE task_file IS NOT NULL
+              AND task_file NOT IN (SELECT task_file FROM tasks WHERE task_file IS NOT NULL)
+              ${orphanScope.sql}`,
+        args: [...orphanScope.args]
+      });
+    } catch {
+    }
+    try {
+      const { readdirSync: readdirSync2, readFileSync: readFs } = await import("fs");
+      const { STATUS_RE, PRIORITY_RE, TITLE_RE } = await import("../task-scanner-5OQBNC2N.js");
+      const { getProjectName } = await import("../project-name-4SKOH2UO.js");
+      const exeDir = "exe";
+      const entries = readdirSync2(exeDir, { withFileTypes: true });
+      const employeeDirs = entries.filter((e) => e.isDirectory() && !["output", "research"].includes(e.name));
+      for (const dir of employeeDirs) {
+        const employee = dir.name;
+        const taskDir = path.join(exeDir, employee);
+        let files;
+        try {
+          files = readdirSync2(taskDir).filter((f) => f.endsWith(".md"));
+        } catch {
+          continue;
+        }
+        for (const file of files) {
+          const taskFilePath = `exe/${employee}/${file}`;
+          let content;
+          try {
+            content = readFs(path.join(taskDir, file), "utf8");
+          } catch {
+            continue;
+          }
+          const statusMatch = content.match(STATUS_RE);
+          const status = statusMatch?.[1]?.toLowerCase() ?? "open";
+          const titleMatch = content.match(TITLE_RE);
+          const title = titleMatch?.[1] ?? file.replace(/\.md$/, "").replace(/-/g, " ");
+          const priMatch = content.match(PRIORITY_RE);
+          const priority = priMatch?.[1]?.toLowerCase() ?? "p1";
+          const assignedByMatch = content.match(/^\*\*Assigned by:\*\*\s*(\w+)/m);
+          const assignedBy = assignedByMatch?.[1] ?? coordinatorName;
+          const projMatch = content.match(/^\*\*Project:\*\*\s*(.+)/m);
+          const projectName = projMatch?.[1]?.trim() ?? getProjectName(process.cwd());
+          const existing = await client.execute({
+            sql: "SELECT id, status FROM tasks WHERE task_file = ?",
+            args: [taskFilePath]
+          });
+          if (existing.rows.length === 0) {
+            const { createTask } = await import("../lib/tasks.js");
+            await createTask({
+              title,
+              assignedTo: employee,
+              assignedBy,
+              projectName,
+              priority,
+              context: "",
+              taskFile: taskFilePath,
+              skipDispatch: true
+            });
+          } else {
+            const dbStatus = String(existing.rows[0].status);
+            if (dbStatus !== status) {
+              await client.execute({
+                sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE task_file = ?",
+                args: [status, (/* @__PURE__ */ new Date()).toISOString(), taskFilePath]
+              });
+            }
+          }
+        }
+      }
+    } catch (e) {
+      process.stderr.write("[exe-boot] task reconciliation: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    }
+    try {
+      const staleRevScope = sessionScopeFilter();
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'done', updated_at = ?
+            WHERE (assigned_to = ? OR assigned_to = ?)
+              AND status = 'in_progress'
+              AND task_file LIKE '%review-%'
+              AND updated_at < datetime('now', '-1 hour')
+              ${staleRevScope.sql}`,
+        args: [(/* @__PURE__ */ new Date()).toISOString(), coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...staleRevScope.args]
+      });
+    } catch {
+    }
+    try {
+      const staleScope = sessionScopeFilter();
+      const staleReviews = await client.execute({
+        sql: `SELECT id, title, priority FROM tasks
+            WHERE status = 'needs_review'
+              AND task_file LIKE '%review-%'
+              AND updated_at < datetime('now', '-24 hours')${staleScope.sql}`,
+        args: [...staleScope.args]
+      });
+      for (const r of staleReviews.rows) {
+        const pri = String(r.priority).toLowerCase();
+        if (pri !== "p0") {
+          try {
+            await updateTaskStatus({ taskId: String(r.id), status: "done", skipReviewCreation: true });
+          } catch {
+            await client.execute({
+              sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ?",
+              args: [(/* @__PURE__ */ new Date()).toISOString(), String(r.id)]
+            });
+          }
+        }
+      }
+      if (staleReviews.rows.length > 0) {
+        const p0Count = staleReviews.rows.filter((r) => String(r.priority).toLowerCase() === "p0").length;
+        const autoApprovedCount = staleReviews.rows.length - p0Count;
+        if (autoApprovedCount > 0) {
+          briefData.autoApprovedReviews = [
+            ...briefData.autoApprovedReviews ?? [],
+            `${autoApprovedCount} stale review(s) auto-approved (>24h)`
+          ];
+        }
+      }
+    } catch {
+    }
+    try {
+      for (const reviewDirName of /* @__PURE__ */ new Set(["exe", coordinatorName])) {
+        const reviewDir = path.join(process.cwd(), "exe", reviewDirName);
+        if (existsSync(reviewDir)) {
+          for (const f of readdirSync(reviewDir)) {
+            if (f.startsWith("review-") && f.endsWith(".md")) {
+              try {
+                unlinkSync(path.join(reviewDir, f));
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  let lastBootTimestamp = null;
+  try {
+    const bootResult = await client.execute({
+      sql: "SELECT value FROM sync_meta WHERE key = 'last_exe_boot'",
+      args: []
+    });
+    if (bootResult.rows[0]) {
+      lastBootTimestamp = String(bootResult.rows[0].value);
+    }
+  } catch {
+  }
+  const autoApproved = [];
+  if (!briefOnly) {
+    try {
+      const approveScope = sessionScopeFilter();
+      const pendingReviews = await client.execute({
+        sql: `SELECT id, title, priority, result, task_file FROM tasks
+            WHERE status = 'needs_review'${approveScope.sql}
+            ORDER BY priority ASC`,
+        args: [...approveScope.args]
+      });
+      for (const r of pendingReviews.rows) {
+        const taskId = String(r.id);
+        const taskTitle = String(r.title);
+        const priority = String(r.priority).toLowerCase();
+        const resultText = String(r.result ?? "");
+        if (priority === "p0") continue;
+        const testsPass = /tests?\s*pass/i.test(resultText) || /\d+\s*passed/i.test(resultText);
+        if (priority === "p2" && testsPass) {
+          try {
+            await updateTaskStatus({ taskId, status: "done", skipReviewCreation: true });
+          } catch {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            await client.execute({
+              sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ?",
+              args: [now, taskId]
+            });
+          }
+          autoApproved.push(taskTitle);
+        }
+      }
+    } catch {
+    }
+    if (autoApproved.length > 0) {
+      briefData.autoApprovedReviews = autoApproved;
+    }
+    try {
+      await client.execute({
+        sql: `UPDATE behaviors SET active = 0
+            WHERE active = 1 AND updated_at < datetime('now', '-180 days')`,
+        args: []
+      });
+    } catch {
+    }
+    if (!briefOnly) {
+      try {
+        await client.execute({
+          sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_exe_boot', ?)",
+          args: [(/* @__PURE__ */ new Date()).toISOString()]
+        });
+      } catch (e) {
+        process.stderr.write("[exe-boot] update last_exe_boot: " + (e instanceof Error ? e.message : String(e)) + "\n");
+      }
+    }
+  }
+  await Promise.all([
+    // Pending reviews from tasks table
+    (async () => {
+      const revScope = sessionScopeFilter();
+      try {
+        const result = await client.execute({
+          sql: `SELECT t.title, t.priority, t.created_at, t.updated_at,
+                       COALESCE(
+                         (SELECT orig.assigned_to FROM tasks orig WHERE orig.task_file = REPLACE(REPLACE(t.task_file, 'review-', ''), 'exe/exe/', 'exe/' || orig.assigned_to || '/')),
+                         REPLACE(SUBSTR(t.title, INSTR(t.title, 'review-') + 7), SUBSTR(t.title, INSTR(t.title, '-')), '')
+                       ) as original_assignee
+                FROM tasks t
+                WHERE (t.assigned_to = ? OR t.assigned_to = ?) AND t.status IN ('open', 'in_progress')
+                  AND t.task_file LIKE '%review-%'${revScope.sql}
+                ORDER BY t.priority ASC, t.created_at ASC`,
+          args: [coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...revScope.args]
+        });
+        briefData.pendingReviews = result.rows.map((row) => ({
+          title: String(row.title),
+          priority: String(row.priority),
+          originalAssignee: String(row.original_assignee || "unknown"),
+          createdAt: String(row.created_at || ""),
+          updatedAt: String(row.updated_at || row.created_at || "")
+        }));
+      } catch {
+        try {
+          const result = await client.execute({
+            sql: `SELECT title, priority, created_at, updated_at
+                  FROM tasks
+                  WHERE (assigned_to = ? OR assigned_to = ?) AND status IN ('open', 'in_progress')
+                    AND task_file LIKE '%review-%'${revScope.sql}
+                  ORDER BY priority ASC, created_at ASC`,
+            args: [coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...revScope.args]
+          });
+          briefData.pendingReviews = result.rows.map((row) => {
+            const title = String(row.title);
+            const match = title.match(/Review:\s*(\w+)\//);
+            return {
+              title,
+              priority: String(row.priority),
+              originalAssignee: match?.[1] ?? "unknown",
+              createdAt: String(row.created_at || ""),
+              updatedAt: String(row.updated_at || row.created_at || "")
+            };
+          });
+        } catch {
+          briefData.pendingReviews = [];
+        }
+      }
+      try {
+        const nrScope = sessionScopeFilter();
+        const nrResult = await client.execute({
+          sql: `SELECT title, priority, assigned_to, created_at, updated_at
+                FROM tasks WHERE status = 'needs_review'${nrScope.sql}
+                ORDER BY updated_at ASC`,
+          args: [...nrScope.args]
+        });
+        const existingTitles = new Set(briefData.pendingReviews.map((r) => r.title));
+        for (const row of nrResult.rows) {
+          const title = String(row.title);
+          if (!existingTitles.has(title)) {
+            briefData.pendingReviews.push({
+              title,
+              priority: String(row.priority),
+              originalAssignee: String(row.assigned_to || "unknown"),
+              createdAt: String(row.created_at || ""),
+              updatedAt: String(row.updated_at || row.created_at || "")
+            });
+          }
+        }
+      } catch {
+      }
+    })(),
+    // Global task queue — all open/in_progress/blocked tasks
+    (async () => {
+      const qScope = sessionScopeFilter(void 0, "t");
+      try {
+        const result = await client.execute({
+          sql: `SELECT t.assigned_to, t.project_name, t.title, t.priority, t.status,
+                       b.task_file as blocker_file, t.parent_task_id, t.updated_at
+                FROM tasks t
+                LEFT JOIN tasks b ON t.blocked_by = b.id
+                WHERE t.status IN ('open', 'in_progress', 'blocked')${qScope.sql}
+                ORDER BY t.parent_task_id NULLS FIRST, t.priority ASC, t.created_at ASC`,
+          args: [...qScope.args]
+        });
+        briefData.globalTasks = result.rows.map((row) => ({
+          assignedTo: String(row.assigned_to),
+          projectName: String(row.project_name),
+          title: String(row.title),
+          priority: String(row.priority),
+          status: String(row.status),
+          blockerFile: row.blocker_file ? String(row.blocker_file) : void 0,
+          parentTaskId: row.parent_task_id ? String(row.parent_task_id) : void 0,
+          updatedAt: row.updated_at ? String(row.updated_at) : void 0
+        }));
+      } catch {
+        briefData.globalTasks = [];
+      }
+    })(),
+    // Completed tasks since last boot
+    (async () => {
+      if (!lastBootTimestamp) return;
+      const cScope = sessionScopeFilter();
+      try {
+        const result = await client.execute({
+          sql: `SELECT assigned_to, title, project_name,
+                       (julianday(updated_at) - julianday(created_at)) * 24 * 60 as duration_minutes
+                FROM tasks
+                WHERE status = 'done' AND updated_at > ?${cScope.sql}
+                ORDER BY assigned_to, updated_at ASC`,
+          args: [lastBootTimestamp, ...cScope.args]
+        });
+        briefData.completedSinceLastBoot = result.rows.map((row) => ({
+          assignedTo: String(row.assigned_to),
+          title: String(row.title),
+          projectName: String(row.project_name),
+          durationMinutes: Number(row.duration_minutes) || 0
+        }));
+      } catch {
+        briefData.completedSinceLastBoot = [];
+      }
+    })(),
+    // Workload per employee
+    (async () => {
+      const wScope = sessionScopeFilter();
+      try {
+        const result = await client.execute({
+          sql: `SELECT assigned_to,
+                  SUM(CASE WHEN status = 'open' THEN 1 ELSE 0 END) as open_count,
+                  SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) as active_count,
+                  SUM(CASE WHEN status = 'done' AND updated_at > datetime('now', '-7 days') THEN 1 ELSE 0 END) as done_7d
+                FROM tasks
+                WHERE 1=1${wScope.sql}
+                GROUP BY assigned_to
+                ORDER BY open_count DESC`,
+          args: [...wScope.args]
+        });
+        briefData.workload = result.rows.map((row) => ({
+          assignedTo: String(row.assigned_to),
+          openCount: Number(row.open_count) || 0,
+          activeCount: Number(row.active_count) || 0,
+          done7d: Number(row.done_7d) || 0
+        }));
+      } catch {
+        briefData.workload = [];
+      }
+    })(),
+    // Velocity (7-day)
+    (async () => {
+      const vScope = sessionScopeFilter();
+      try {
+        const velocityResult = await client.execute({
+          sql: `SELECT assigned_to,
+                  COUNT(*) as completed,
+                  AVG((julianday(updated_at) - julianday(created_at)) * 24) as avg_hours
+                FROM tasks
+                WHERE status = 'done' AND updated_at > datetime('now', '-7 days')${vScope.sql}
+                GROUP BY assigned_to
+                ORDER BY completed DESC`,
+          args: [...vScope.args]
+        });
+        const errScope = sessionScopeFilter();
+        const errorResult = await client.execute({
+          sql: `SELECT agent_id, COUNT(*) as error_count
+                FROM notifications
+                WHERE event = 'error_spike' AND created_at > datetime('now', '-7 days')
+                ${errScope.sql}
+                GROUP BY agent_id`,
+          args: [...errScope.args]
+        });
+        const errorMap = /* @__PURE__ */ new Map();
+        for (const row of errorResult.rows) {
+          errorMap.set(String(row.agent_id), Number(row.error_count) || 0);
+        }
+        briefData.velocity = velocityResult.rows.map((row) => ({
+          assignedTo: String(row.assigned_to),
+          completed: Number(row.completed) || 0,
+          avgHours: Number(row.avg_hours) || 0,
+          errors: errorMap.get(String(row.assigned_to)) ?? 0
+        }));
+      } catch {
+        briefData.velocity = [];
+      }
+    })(),
+    // Active projects
+    (async () => {
+      try {
+        const apScope = sessionScopeFilter();
+        const result = await client.execute({
+          sql: `SELECT DISTINCT project_name FROM tasks
+                WHERE status IN ('open', 'in_progress', 'blocked')
+                  AND project_name IS NOT NULL AND project_name != '' AND project_name != 'unknown'${apScope.sql}`,
+          args: [...apScope.args]
+        });
+        briefData.activeProjects = result.rows.map((row) => String(row.project_name));
+      } catch {
+        briefData.activeProjects = [];
+      }
+    })(),
+    // Flagged issues
+    (async () => {
+      try {
+        const result = await client.execute({
+          sql: `SELECT agent_id, tool_name, timestamp, raw_text
+                FROM memories WHERE has_error = 1
+                  AND timestamp > datetime('now', '-1 day')
+                ORDER BY timestamp DESC LIMIT 5`,
+          args: []
+        });
+        briefData.flaggedIssues = result.rows.map((row) => ({
+          agentId: row.agent_id,
+          timestamp: row.timestamp,
+          toolName: row.tool_name,
+          rawText: row.raw_text
+        }));
+      } catch {
+      }
+    })(),
+    // Failed messages
+    (async () => {
+      try {
+        const failScope = sessionScopeFilter();
+        const result = await client.execute({
+          sql: `SELECT id, target_agent, content, failure_reason
+                FROM messages WHERE status = 'failed'
+                ${failScope.sql}
+                ORDER BY created_at DESC LIMIT 10`,
+          args: [...failScope.args]
+        });
+        briefData.failedMessages = result.rows.map((row) => ({
+          id: row.id,
+          targetAgent: row.target_agent,
+          content: row.content,
+          failureReason: row.failure_reason ?? null
+        }));
+      } catch {
+      }
+    })(),
+    // Active reminders
+    (async () => {
+      try {
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        const result = await client.execute({
+          sql: `SELECT text, due_date FROM reminders WHERE completed_at IS NULL ORDER BY due_date ASC NULLS LAST`,
+          args: []
+        });
+        briefData.reminders = result.rows.map((row) => {
+          const dueDate = row.due_date ? String(row.due_date) : null;
+          const overdue = dueDate ? dueDate < today : false;
+          return { text: String(row.text), dueDate, overdue };
+        });
+      } catch {
+      }
+    })(),
+    // Projects with open tasks + last activity
+    (async () => {
+      const pScope = sessionScopeFilter();
+      try {
+        const { getProjectName } = await import("../project-name-4SKOH2UO.js");
+        const currentProject = getProjectName(process.cwd());
+        const result = await client.execute({
+          sql: `SELECT p.project_name,
+                       COALESCE(t.open_count, 0) as open_count,
+                       t.assignees,
+                       m.last_activity
+                FROM (
+                  SELECT DISTINCT project_name FROM tasks WHERE 1=1${pScope.sql}
+                  UNION
+                  SELECT DISTINCT project_name FROM memories
+                    WHERE timestamp > datetime('now', '-30 days')
+                ) p
+                LEFT JOIN (
+                  SELECT project_name,
+                         COUNT(*) as open_count,
+                         GROUP_CONCAT(DISTINCT assigned_to) as assignees
+                  FROM tasks WHERE status IN ('open', 'in_progress')${pScope.sql}
+                  GROUP BY project_name
+                ) t ON p.project_name = t.project_name
+                LEFT JOIN (
+                  SELECT project_name, MAX(timestamp) as last_activity
+                  FROM memories GROUP BY project_name
+                ) m ON p.project_name = m.project_name
+                WHERE p.project_name IS NOT NULL AND p.project_name != ''
+                ORDER BY COALESCE(t.open_count, 0) DESC, m.last_activity DESC`,
+          args: [...pScope.args, ...pScope.args]
+        });
+        const projects = result.rows.map((row) => ({
+          projectName: String(row.project_name),
+          openTasks: Number(row.open_count) || 0,
+          assignees: row.assignees ? String(row.assignees).split(",") : [],
+          lastActivity: row.last_activity ? String(row.last_activity) : "",
+          isCurrent: String(row.project_name) === currentProject,
+          recentTasks: [],
+          velocity7d: 0,
+          commits7d: void 0,
+          blockedCount: void 0,
+          sessionName: void 0,
+          teamActivity: void 0
+        }));
+        for (const p of projects) {
+          try {
+            const tasksResult = await client.execute({
+              sql: `SELECT assigned_to, title, updated_at FROM tasks
+                    WHERE project_name = ? AND status = 'done'${pScope.sql}
+                    ORDER BY updated_at DESC LIMIT 5`,
+              args: [p.projectName, ...pScope.args]
+            });
+            p.recentTasks = tasksResult.rows.map((r) => ({
+              assignedTo: String(r.assigned_to),
+              title: String(r.title),
+              updatedAt: String(r.updated_at)
+            }));
+            const actResult = await client.execute({
+              sql: `SELECT assigned_to,
+                      SUM(CASE WHEN task_file NOT LIKE '%review-%' THEN 1 ELSE 0 END) as tasks_done,
+                      SUM(CASE WHEN task_file LIKE '%review-%' THEN 1 ELSE 0 END) as reviews_cleared
+                    FROM tasks
+                    WHERE project_name = ? AND status = 'done'
+                      AND updated_at > datetime('now', '-7 days')${pScope.sql}
+                    GROUP BY assigned_to`,
+              args: [p.projectName, ...pScope.args]
+            });
+            const activity = actResult.rows.map((r) => ({
+              name: String(r.assigned_to),
+              tasksDone: Number(r.tasks_done) || 0,
+              reviewsCleared: Number(r.reviews_cleared) || 0
+            }));
+            const assignedResult = await client.execute({
+              sql: `SELECT COUNT(*) as cnt FROM tasks
+                    WHERE project_name = ? AND assigned_by = ?
+                      AND created_at > datetime('now', '-7 days')${pScope.sql}`,
+              args: [p.projectName, coordinatorName, ...pScope.args]
+            });
+            const tasksAssigned = Number(assignedResult.rows[0]?.cnt) || 0;
+            if (tasksAssigned > 0) {
+              const exeEntry = activity.find((a) => a.name === coordinatorName || isCoordinatorName(a.name));
+              if (exeEntry) {
+                exeEntry.tasksAssigned = tasksAssigned;
+              } else {
+                activity.push({ name: coordinatorName, tasksDone: 0, reviewsCleared: 0, tasksAssigned });
+              }
+            }
+            p.teamActivity = activity;
+            const blockedResult = await client.execute({
+              sql: `SELECT COUNT(*) as cnt FROM tasks
+                    WHERE project_name = ? AND status = 'blocked'${pScope.sql}`,
+              args: [p.projectName, ...pScope.args]
+            });
+            p.blockedCount = Number(blockedResult.rows[0]?.cnt) || 0;
+          } catch {
+          }
+        }
+        try {
+          const { listSessions: listRegistrySessions } = await import("../lib/session-registry.js");
+          const regSessions = listRegistrySessions();
+          for (const s of regSessions) {
+            const projName = s.projectDir.split("/").pop() ?? "";
+            const proj = projects.find((p) => p.projectName === projName);
+            if (!proj || proj.sessionName) continue;
+            if (s.agentId === coordinatorName || isCoordinatorName(s.agentId)) {
+              proj.sessionName = s.windowName;
+            } else if (s.parentExe) {
+              proj.sessionName = s.parentExe;
+            }
+          }
+        } catch {
+        }
+        try {
+          const { execSync: execGit } = await import("child_process");
+          const projDirs = /* @__PURE__ */ new Map();
+          projDirs.set(currentProject, process.cwd());
+          try {
+            const { listSessions: ls2 } = await import("../lib/session-registry.js");
+            for (const s of ls2()) {
+              const name = s.projectDir.split("/").pop() ?? "";
+              if (name && !projDirs.has(name)) projDirs.set(name, s.projectDir);
+            }
+          } catch {
+          }
+          for (const p of projects) {
+            const dir = projDirs.get(p.projectName);
+            if (!dir) continue;
+            try {
+              const count = execGit(
+                'git log --oneline --since="7 days ago" --grep="Co-Authored-By: Claude" --grep="^task(" --all-match 2>/dev/null | wc -l; git log --oneline --since="7 days ago" --grep="Co-Authored-By: Claude" 2>/dev/null | wc -l; git log --oneline --since="7 days ago" --grep="^task(" 2>/dev/null | wc -l',
+                { encoding: "utf8", timeout: 3e3, cwd: dir }
+              ).trim();
+              const counts = count.split("\n").map((l) => parseInt(l.trim(), 10) || 0);
+              const maxCount = Math.max(...counts);
+              if (maxCount > 0) p.commits7d = maxCount;
+            } catch {
+            }
+          }
+        } catch {
+        }
+        briefData.projects = projects;
+      } catch {
+        briefData.projects = [];
+      }
+    })(),
+    // Memory stats per employee
+    (async () => {
+      try {
+        const result = await client.execute({
+          sql: `SELECT agent_id,
+                       COUNT(*) as total,
+                       SUM(CASE WHEN timestamp > datetime('now', '-7 days') THEN 1 ELSE 0 END) as growth_7d
+                FROM memories
+                WHERE agent_id != 'default'
+                GROUP BY agent_id
+                ORDER BY total DESC`,
+          args: []
+        });
+        briefData.memoryStats = result.rows.map((row) => ({
+          agentId: String(row.agent_id),
+          totalMemories: Number(row.total) || 0,
+          growth7d: Number(row.growth_7d) || 0
+        }));
+      } catch {
+        briefData.memoryStats = [];
+      }
+    })(),
+    // Recent completed tasks for current project + git commits
+    (async () => {
+      try {
+        const { getProjectName } = await import("../project-name-4SKOH2UO.js");
+        const currentProject = getProjectName(process.cwd());
+        briefData.currentProject = currentProject;
+        const rctScope = sessionScopeFilter();
+        const result = await client.execute({
+          sql: `SELECT assigned_to, title, updated_at
+                FROM tasks
+                WHERE project_name = ? AND status = 'done'${rctScope.sql}
+                ORDER BY updated_at DESC
+                LIMIT 10`,
+          args: [currentProject, ...rctScope.args]
+        });
+        briefData.recentProjectTasks = result.rows.map((row) => ({
+          assignedTo: String(row.assigned_to),
+          title: String(row.title),
+          updatedAt: String(row.updated_at)
+        }));
+        try {
+          const { execSync: execSync2 } = await import("child_process");
+          const gitLog = execSync2(
+            "git log --oneline -10 --grep='Co-Authored-By: Claude' --grep='task(' --all-match 2>/dev/null || git log --oneline -5 --grep='Co-Authored-By: Claude' 2>/dev/null || git log --oneline -5 --grep='^task(' 2>/dev/null",
+            {
+              encoding: "utf8",
+              timeout: 3e3,
+              cwd: process.cwd()
+            }
+          ).trim();
+          if (gitLog) {
+            const seen = /* @__PURE__ */ new Set();
+            briefData.recentCommits = gitLog.split("\n").filter((line) => {
+              if (!line || seen.has(line)) return false;
+              seen.add(line);
+              return true;
+            }).slice(0, 3);
+          }
+        } catch {
+        }
+      } catch {
+      }
+    })()
+  ]);
+  try {
+    const configPath = path.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(os.homedir(), ".exe-os"),
+      "config.json"
+    );
+    if (existsSync(configPath)) {
+      const raw = JSON.parse(readFileSync(configPath, "utf8"));
+      briefData.cloudConnected = !!(raw.cloud || raw.turso);
+    }
+  } catch {
+  }
+  try {
+    const backfillFlagPath = path.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+    const isBackfillNeeded = () => existsSync(backfillFlagPath);
+    const coverageResult = await client.execute({
+      sql: `SELECT COUNT(*) as total,
+                   SUM(CASE WHEN vector IS NOT NULL THEN 1 ELSE 0 END) as with_vectors
+            FROM memories`,
+      args: []
+    });
+    const totalMemories = Number(coverageResult.rows[0]?.total) || 0;
+    const memoriesWithVectors = Number(coverageResult.rows[0]?.with_vectors) || 0;
+    const nullCount = totalMemories - memoriesWithVectors;
+    const recentResult = await client.execute({
+      sql: `SELECT COUNT(*) as total,
+                   SUM(CASE WHEN vector IS NOT NULL THEN 1 ELSE 0 END) as with_vec
+            FROM memories
+            WHERE timestamp > datetime('now', '-24 hours')`,
+      args: []
+    });
+    const recent24hTotal = Number(recentResult.rows[0]?.total) || 0;
+    const recent24hWithVectors = Number(recentResult.rows[0]?.with_vec) || 0;
+    let daemonRunning = false;
+    let daemonUptime;
+    let daemonRequestsServed;
+    const socketPath = path.join(EXE_AI_DIR, "exed.sock");
+    if (existsSync(socketPath)) {
+      try {
+        const net = await import("net");
+        const health = await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            sock.destroy();
+            resolve(null);
+          }, 2e3);
+          const sock = net.createConnection({ path: socketPath });
+          let buf = "";
+          sock.on("connect", () => {
+            sock.write(JSON.stringify({ id: "boot-health", type: "health" }) + "\n");
+          });
+          sock.on("data", (chunk) => {
+            buf += chunk.toString();
+            for (const line of buf.split("\n")) {
+              if (!line) continue;
+              try {
+                const resp = JSON.parse(line);
+                if (resp.health) {
+                  clearTimeout(timer);
+                  sock.destroy();
+                  resolve(resp.health);
+                }
+              } catch {
+              }
+            }
+          });
+          sock.on("error", () => {
+            clearTimeout(timer);
+            resolve(null);
+          });
+        });
+        if (health) {
+          daemonRunning = true;
+          daemonUptime = health.uptime;
+          daemonRequestsServed = health.requests_served;
+        }
+      } catch {
+      }
+    }
+    if (!daemonRunning) {
+      const pidPath = path.join(EXE_AI_DIR, "exed.pid");
+      if (existsSync(pidPath)) {
+        try {
+          const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+          if (pid > 0) {
+            process.kill(pid, 0);
+            daemonRunning = true;
+          }
+        } catch {
+        }
+      }
+    }
+    if (nullCount === 0) {
+      try {
+        const flagPath = path.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+        if (existsSync(flagPath)) {
+          const { unlinkSync: unlinkSync2 } = await import("fs");
+          unlinkSync2(flagPath);
+        }
+      } catch {
+      }
+    }
+    briefData.embedding = {
+      daemonRunning,
+      daemonUptime,
+      daemonRequestsServed,
+      totalMemories,
+      memoriesWithVectors,
+      backfillRunning: nullCount > 0 && isBackfillNeeded(),
+      recent24hTotal,
+      recent24hWithVectors
+    };
+    if (nullCount > 0) {
+      try {
+        const { tryAcquireWorkerSlot, registerWorkerPid } = await import("../worker-gate-GFKXZ6V5.js");
+        if (!tryAcquireWorkerSlot()) {
+          process.stderr.write("[exe-boot] Backfill needed but worker gate full \u2014 skipping\n");
+        } else {
+          const { spawn } = await import("child_process");
+          const { fileURLToPath } = await import("url");
+          const thisFile = fileURLToPath(import.meta.url);
+          const backfillPath = path.resolve(path.dirname(thisFile), "backfill-vectors.js");
+          if (existsSync(backfillPath)) {
+            const { openSync, closeSync } = await import("fs");
+            const workerLogPath = path.join(EXE_AI_DIR, "workers.log");
+            let stderrFd = "ignore";
+            try {
+              stderrFd = openSync(workerLogPath, "a");
+            } catch {
+            }
+            const child = spawn(process.execPath, [backfillPath], {
+              detached: true,
+              stdio: ["ignore", "ignore", stderrFd]
+            });
+            child.unref();
+            if (child.pid) registerWorkerPid(child.pid);
+            if (typeof stderrFd === "number") try {
+              closeSync(stderrFd);
+            } catch {
+            }
+            briefData.embedding.backfillRunning = true;
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    const { fileURLToPath } = await import("url");
+    const thisFile = fileURLToPath(import.meta.url);
+    const criticalBinaries = ["backfill-vectors.js", "scan-tasks.js"];
+    const missing = [];
+    for (const bin of criticalBinaries) {
+      const binPath = path.resolve(path.dirname(thisFile), bin);
+      if (!existsSync(binPath)) {
+        missing.push(`dist/bin/${bin}`);
+      }
+    }
+    if (missing.length > 0) {
+      briefData.missingBinaries = missing;
+    }
+  } catch {
+  }
+  try {
+    const { countKillsSince } = await import("../session-kill-telemetry-JHSI7D3F.js");
+    const { listSessions: listRegistrySessions } = await import("../lib/session-registry.js");
+    const todayStart = /* @__PURE__ */ new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    briefData.sessionsKilledToday = await countKillsSince(todayStart.toISOString());
+    const liveSessionCount = listRegistrySessions().length;
+    briefData.idleKillSuspectBroken = await updateIdleKillSuspectStreak(
+      client,
+      briefData.sessionsKilledToday,
+      liveSessionCount,
+      todayStart.toISOString().slice(0, 10)
+    );
+  } catch {
+  }
+  const brief = await generateStatusBrief(employees, briefData);
+  if (briefOnly) {
+    console.log(brief);
+    return;
+  }
+  const sessionDir = path.join(EXE_AI_DIR, "sessions", coordinatorName);
+  await mkdir(sessionDir, { recursive: true });
+  const coordinatorIdentityPath = path.join(EXE_AI_DIR, "identity", `${coordinatorName}.md`);
+  const coordinatorPrompt = existsSync(coordinatorIdentityPath) ? readFileSync(coordinatorIdentityPath, "utf-8") : coordinatorEmployee.systemPrompt ?? "";
+  const claudeMdContent = `${getSessionPrompt(coordinatorPrompt)}
+
+---
+
+# Status Brief
+
+${brief}`;
+  await writeFile(path.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
+  const notificationSessionScope = resolveExeSession();
+  const unread = await readUnreadNotifications(void 0, notificationSessionScope);
+  if (unread.length > 0) {
+    console.log(`\u{1F4EC} ${unread.length} unread notification${unread.length === 1 ? "" : "s"}`);
+    await markAsRead(unread.map((n) => n.id), notificationSessionScope);
+  }
+  await cleanupOldNotifications(void 0, notificationSessionScope);
+  console.log(brief);
+  try {
+    const configPath2 = path.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(os.homedir(), ".exe-os"),
+      "config.json"
+    );
+    if (existsSync(configPath2)) {
+      const rawCfg = JSON.parse(readFileSync(configPath2, "utf8"));
+      const cloudCfg = rawCfg.cloud;
+      if (cloudCfg?.apiKey) {
+        const { initSyncCrypto, isSyncCryptoInitialized } = await import("../lib/crypto.js");
+        if (!isSyncCryptoInitialized()) {
+          const { getMasterKey } = await import("../lib/keychain.js");
+          const mk = await getMasterKey();
+          if (mk) initSyncCrypto(mk);
+        }
+        const { cloudSync } = await import("../lib/cloud-sync.js");
+        cloudSync({ apiKey: cloudCfg.apiKey, endpoint: cloudCfg.endpoint ?? "" }).catch(() => {
+        });
+      }
+    }
+  } catch {
+  }
+  try {
+    const { listSchedules } = await import("../lib/schedules.js");
+    const schedules = await listSchedules(true);
+    const sessionSchedules = schedules.filter((s) => !s.useCrontab);
+    if (sessionSchedules.length > 0) {
+      console.log(`
+[SCHEDULES] ${sessionSchedules.length} session-scoped schedule(s) to re-register:`);
+      for (const s of sessionSchedules) {
+        console.log(`  CronCreate: cron="${s.cron}" prompt="${s.prompt ?? s.description}"`);
+      }
+    }
+  } catch {
+  }
+}
+async function updateIdleKillSuspectStreak(client, killsToday, liveSessions, todayDate) {
+  try {
+    const {
+      IDLE_KILL_STREAK_META_KEY,
+      computeIdleKillSuspectStreak,
+      parseStreakState
+    } = await import("../session-kill-telemetry-JHSI7D3F.js");
+    const prevResult = await client.execute({
+      sql: "SELECT value FROM sync_meta WHERE key = ?",
+      args: [IDLE_KILL_STREAK_META_KEY]
+    });
+    const prevRaw = prevResult.rows[0]?.value;
+    const prev = parseStreakState(prevRaw ?? null);
+    const { state, suspect } = computeIdleKillSuspectStreak(
+      prev,
+      killsToday,
+      liveSessions,
+      todayDate
+    );
+    await client.execute({
+      sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES (?, ?)",
+      args: [IDLE_KILL_STREAK_META_KEY, JSON.stringify(state)]
+    });
+    return suspect;
+  } catch {
+    return false;
+  }
+}
+function runSplash() {
+  try {
+    const config = loadConfigSync();
+    if (!config.splashEffect) return;
+    execSync(
+      'echo "EXE OS" | python3 -m terminaltexteffects decrypt --typing-speed 2 --ciphertext-colors 6B4C9A F5D76E --final-gradient-stops F5D76E F0EDE8 --final-gradient-direction vertical',
+      { stdio: "inherit", timeout: 5e3 }
+    );
+  } catch {
+  }
+}
+if (isMainModule(import.meta.url)) {
+  const briefOnly = process.argv.includes("--brief-only");
+  if (!briefOnly) {
+    runSplash();
+  }
+  boot({ briefOnly }).catch((err) => {
+    console.error(
+      "Boot failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(1);
+  });
+}
+export {
+  boot
+};