@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-SEUST6U5.js

@@ -0,0 +1,284 @@
+import {
+  routeTask
+} from "./chunk-YMLM5D65.js";
+import {
+  createTaskCore,
+  employeeSessionName,
+  ensureEmployee,
+  getSessionState,
+  isEmployeeAlive,
+  sessionScopeFilter,
+  updateTaskStatus
+} from "./chunk-5M5RYJ22.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorName
+} from "./chunk-CHBHR5W6.js";
+
+// src/runtime/orchestrator.ts
+var STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;
+var MultiAgentOrchestrator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Route and dispatch a single task to the best-fit employee.
+   */
+  async dispatchTask(task) {
+    let targetEmployee;
+    let routingScore = 0;
+    if (task.assignTo) {
+      const found = this.config.employees.find((e) => e.name === task.assignTo);
+      if (!found) {
+        return {
+          employee: task.assignTo,
+          sessionName: "",
+          status: "failed",
+          routingScore: 0,
+          error: `Employee "${task.assignTo}" not found`
+        };
+      }
+      targetEmployee = found;
+      routingScore = 1;
+    } else {
+      const routed = await routeTask(
+        `${task.title}
+${task.context}`,
+        this.config.employees,
+        this.config.embedFn,
+        this.config.searchFn
+      );
+      targetEmployee = routed.employee;
+      routingScore = routed.score;
+    }
+    try {
+      await createTaskCore({
+        title: task.title,
+        assignedTo: targetEmployee.name,
+        assignedBy: getCoordinatorName(),
+        projectName: task.projectName,
+        priority: task.priority,
+        context: task.context,
+        baseDir: this.config.projectDir,
+        skipDispatch: true
+      });
+    } catch (err) {
+      return {
+        employee: targetEmployee.name,
+        sessionName: "",
+        status: "failed",
+        routingScore,
+        error: `Task creation failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const result = ensureEmployee(
+      targetEmployee.name,
+      this.config.exeSession,
+      this.config.projectDir,
+      task.spawnOpts
+    );
+    return {
+      employee: targetEmployee.name,
+      sessionName: result.sessionName,
+      status: result.status === "failed" ? "failed" : result.status === "spawned" ? "dispatched" : "already_running",
+      routingScore,
+      error: result.error
+    };
+  }
+  /**
+   * Check health of all employees. Detect stuck and idle agents.
+   */
+  async healthCheck() {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const employees = [];
+    const stuckAgents = [];
+    const idleAgents = [];
+    const crashedSessions = [];
+    let totalOpen = 0;
+    let totalInProgress = 0;
+    for (const emp of this.config.employees) {
+      const sessionName = employeeSessionName(emp.name, this.config.exeSession);
+      const alive = isEmployeeAlive(sessionName);
+      const state = alive ? getSessionState(sessionName) : "offline";
+      const oScope = sessionScopeFilter();
+      const tasks = await client.execute({
+        sql: `SELECT title, status, updated_at FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${oScope.sql}
+              ORDER BY priority ASC`,
+        args: [emp.name, ...oScope.args]
+      });
+      const openCount = tasks.rows.filter((r) => r.status === "open").length;
+      const inProgressCount = tasks.rows.filter((r) => r.status === "in_progress").length;
+      totalOpen += openCount;
+      totalInProgress += inProgressCount;
+      const staleTasks = [];
+      for (const row of tasks.rows) {
+        if (row.status === "in_progress" && row.updated_at) {
+          const age = Date.now() - new Date(String(row.updated_at)).getTime();
+          if (age > STALE_THRESHOLD_MS) {
+            staleTasks.push(String(row.title));
+          }
+        }
+      }
+      const crashed = !alive && inProgressCount > 0;
+      if (staleTasks.length > 0) {
+        stuckAgents.push(emp.name);
+      }
+      if (crashed) {
+        crashedSessions.push(emp.name);
+      }
+      if (alive && state === "idle" && openCount + inProgressCount === 0) {
+        idleAgents.push(emp.name);
+      }
+      employees.push({
+        name: emp.name,
+        role: emp.role,
+        sessionName,
+        alive,
+        crashed,
+        state,
+        taskCount: openCount + inProgressCount,
+        inProgressCount,
+        staleTasks
+      });
+    }
+    return {
+      employees,
+      stuckAgents,
+      idleAgents,
+      crashedSessions,
+      totalOpenTasks: totalOpen,
+      totalInProgress
+    };
+  }
+  /**
+   * Process completed reviews. Auto-approve P2 tasks with passing results.
+   */
+  async processReviews() {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const autoApproved = [];
+    const needsReview = [];
+    const coordinatorName = getCoordinatorName();
+    const rScope = sessionScopeFilter();
+    const reviews = await client.execute({
+      sql: `SELECT id, title, assigned_to, priority, result, task_file FROM tasks
+            WHERE (assigned_to = ? OR assigned_to = ?)
+              AND status IN ('open', 'in_progress')
+              AND task_file LIKE '%review-%'${rScope.sql}
+            ORDER BY priority ASC
+            LIMIT 20`,
+      args: [coordinatorName, DEFAULT_COORDINATOR_TEMPLATE_NAME, ...rScope.args]
+    });
+    for (const row of reviews.rows) {
+      const item = {
+        taskId: String(row.id),
+        title: String(row.title),
+        assignedTo: String(row.assigned_to),
+        priority: String(row.priority),
+        result: String(row.result ?? ""),
+        taskFile: String(row.task_file)
+      };
+      if (this.config.autoApproveP2 && item.priority === "p2" && /tests?\s+pass/i.test(item.result)) {
+        try {
+          await updateTaskStatus({
+            taskId: item.taskId,
+            status: "done",
+            result: `[auto-approved] ${item.result}`,
+            skipReviewCreation: true
+          });
+        } catch {
+          await client.execute({
+            sql: `UPDATE tasks SET status = 'done', result = ? WHERE id = ?`,
+            args: [`[auto-approved] ${item.result}`, item.taskId]
+          });
+        }
+        autoApproved.push(item);
+      } else {
+        needsReview.push(item);
+      }
+    }
+    return {
+      autoApproved,
+      needsReview,
+      processed: autoApproved.length + needsReview.length
+    };
+  }
+  /**
+   * Run one full orchestration cycle: health check + process reviews.
+   * Does NOT dispatch tasks — call dispatchTask() explicitly.
+   */
+  async tick() {
+    const health = await this.healthCheck();
+    const reviews = await this.processReviews();
+    for (const stuck of health.stuckAgents) {
+      const sessionName = employeeSessionName(stuck, this.config.exeSession);
+      if (isEmployeeAlive(sessionName)) {
+        const { sendIntercom } = await import("./lib/tmux-routing.js");
+        sendIntercom(sessionName);
+      }
+    }
+    for (const crashed of health.crashedSessions) {
+      this.recoverSession(crashed);
+    }
+    return {
+      dispatched: [],
+      health,
+      reviews,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Recover a crashed session by spawning a fresh CC session.
+   * The new session boots with identity via --system-prompt, finds existing in_progress tasks, and resumes.
+   */
+  recoverSession(employeeName) {
+    const sessionName = employeeSessionName(employeeName, this.config.exeSession);
+    const result = ensureEmployee(
+      employeeName,
+      this.config.exeSession,
+      this.config.projectDir
+    );
+    if (result.status === "failed") {
+      return { status: "failed", sessionName, error: result.error };
+    }
+    return { status: "recovered", sessionName: result.sessionName };
+  }
+  /**
+   * Dispatch a batch of tasks, auto-routing each to the best employee.
+   */
+  async dispatchBatch(tasks) {
+    const results = [];
+    for (const task of tasks) {
+      const result = await this.dispatchTask(task);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Get a formatted status summary (matches exe boot brief style).
+   */
+  async getStatusSummary() {
+    const health = await this.healthCheck();
+    const lines = [];
+    lines.push("\u25B8 ORCHESTRATOR STATUS");
+    lines.push(`  Tasks:   ${health.totalOpenTasks} open, ${health.totalInProgress} in progress`);
+    lines.push(`  Crashed: ${health.crashedSessions.length > 0 ? health.crashedSessions.join(", ") : "none"}`);
+    lines.push(`  Stuck:   ${health.stuckAgents.length > 0 ? health.stuckAgents.join(", ") : "none"}`);
+    lines.push(`  Idle:    ${health.idleAgents.length > 0 ? health.idleAgents.join(", ") : "none"}`);
+    lines.push("");
+    for (const emp of health.employees) {
+      const stateIcon = emp.alive ? emp.state === "idle" ? "\u{1F7E2}" : emp.state === "thinking" ? "\u{1F7E1}" : emp.state === "tool" ? "\u{1F535}" : "\u26AA" : "\u{1F534}";
+      const taskInfo = emp.taskCount > 0 ? `${emp.taskCount} task${emp.taskCount > 1 ? "s" : ""} (${emp.inProgressCount} active)` : "idle";
+      const staleWarning = emp.staleTasks.length > 0 ? ` \u26A0 stale: ${emp.staleTasks[0]}` : "";
+      lines.push(`  ${stateIcon} ${emp.name} (${emp.role}): ${taskInfo}${staleWarning}`);
+    }
+    return lines.join("\n");
+  }
+};
+
+export {
+  MultiAgentOrchestrator
+};

package/dist/chunk-SG2ANG5C.js

@@ -0,0 +1,123 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.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-SUEQF3ZS.js

@@ -0,0 +1,214 @@
+import {
+  sessionScopeFilter
+} from "./chunk-5M5RYJ22.js";
+
+// src/lib/git-task-sweep.ts
+import { execSync } from "child_process";
+var DEFAULT_COMMIT_LIMIT = 50;
+var DEFAULT_STALE_MINUTES = 10;
+var AUTO_ESCALATE_THRESHOLD = 0.6;
+var EXACT_UUID_SCORE = 1;
+var TITLE_KEYWORD_SCORE = 0.5;
+var FILE_PATH_SCORE = 0.3;
+var MIN_KEYWORD_OVERLAP = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "as",
+  "be",
+  "was",
+  "are",
+  "this",
+  "that",
+  "not",
+  "no",
+  "if",
+  "so",
+  "do",
+  "up"
+]);
+function extractKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+}
+function matchScore(task, commitMessage, changedFiles) {
+  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
+    return EXACT_UUID_SCORE;
+  }
+  let score = 0;
+  const titleWords = extractKeywords(task.title);
+  const commitWords = new Set(extractKeywords(commitMessage));
+  const overlap = titleWords.filter((w) => commitWords.has(w));
+  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
+    score += TITLE_KEYWORD_SCORE;
+  }
+  if (task.context && changedFiles.length > 0) {
+    const contextLower = task.context.toLowerCase();
+    const hasFileMatch = changedFiles.some(
+      (f) => contextLower.includes(f.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += FILE_PATH_SCORE;
+    }
+  }
+  return score;
+}
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
+  try {
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function isStale(updatedAt, staleMinutes) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes * 6e4;
+  return updated < threshold;
+}
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
+  }
+  return best;
+}
+async function sweepTasks(projectName, options = {}) {
+  const commitLimit = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun = options.dryRun ?? false;
+  const result = { escalated: [], unchanged: 0, errors: [] };
+  const commits = getRecentCommits(commitLimit);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
+  try {
+    const { initStore } = await import("./lib/store.js");
+    await initStore();
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const conditions = ["status = 'in_progress'"];
+    const args = [];
+    if (projectName) {
+      conditions.push("project_name = ?");
+      args.push(projectName);
+    }
+    const swScope = sessionScopeFilter();
+    if (swScope.sql) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(...swScope.args);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args
+    });
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (tasks.length === 0) {
+    return result;
+  }
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes)) {
+      result.unchanged++;
+      continue;
+    }
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        const { updateTaskStatus } = await import("./tasks-crud-JIS5B4GZ.js");
+        await updateTaskStatus({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
+        });
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+    }
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
+  }
+  return result;
+}
+
+export {
+  extractKeywords,
+  matchScore,
+  getRecentCommits,
+  findBestMatch,
+  sweepTasks
+};