@askexenow/exe-os 0.9.265 → 0.9.267

package/dist/chunk-UTVNIAOF.js

@@ -0,0 +1,284 @@
+import {
+  routeTask
+} from "./chunk-S2ARWNS6.js";
+import {
+  createTaskCore,
+  employeeSessionName,
+  ensureEmployee,
+  getSessionState,
+  isEmployeeAlive,
+  sessionScopeFilter,
+  updateTaskStatus
+} from "./chunk-KBYRYSXT.js";
+import {
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  getCoordinatorName
+} from "./chunk-RHZ2CRJU.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-VF6VT4MR.js

@@ -0,0 +1,70 @@
+import {
+  loadEmployees
+} from "./chunk-RHZ2CRJU.js";
+
+// src/lib/agent-symlinks.ts
+import os from "os";
+import path from "path";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  symlinkSync
+} from "fs";
+function claudeAgentsDir(homeDir) {
+  return path.join(homeDir, ".claude", "agents");
+}
+function identitySourcePath(homeDir, agentId) {
+  return path.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+}
+function claudeAgentLinkPath(homeDir, agentId) {
+  return path.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+}
+function ensureAgentSymlink(agentId, homeDir = os.homedir()) {
+  const target = identitySourcePath(homeDir, agentId);
+  const link = claudeAgentLinkPath(homeDir, agentId);
+  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync(link)) {
+    let stat;
+    try {
+      stat = lstatSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "stat_failed" };
+    }
+    if (!stat.isSymbolicLink()) {
+      return { agentId, action: "conflict", target, link, conflict: "regular_file" };
+    }
+    let currentTarget;
+    try {
+      currentTarget = readlinkSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "readlink_failed" };
+    }
+    if (currentTarget === target) {
+      return { agentId, action: "already_correct", target, link };
+    }
+    return { agentId, action: "conflict", target, link, conflict: `points_to:${currentTarget}` };
+  }
+  try {
+    symlinkSync(target, link);
+  } catch (err) {
+    return {
+      agentId,
+      action: "conflict",
+      target,
+      link,
+      conflict: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { agentId, action: "created", target, link };
+}
+async function ensureAllAgentSymlinks(homeDir = os.homedir()) {
+  const employees = await loadEmployees();
+  return employees.map((emp) => ensureAgentSymlink(emp.name, homeDir));
+}
+
+export {
+  ensureAgentSymlink,
+  ensureAllAgentSymlinks
+};

package/dist/chunk-VZXLYUKS.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-Q3GLQDZI.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};