@askexenow/exe-os 0.9.288 → 0.9.289

package/dist/chunk-LHW7TZGJ.js

@@ -0,0 +1,244 @@
+import {
+  employeeSessionName,
+  ensureEmployee,
+  markAsReadByTaskFile,
+  notifyParentExe,
+  resolveExeSession,
+  sendIntercom
+} from "./chunk-F23GFLKY.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-CMDKYYFK.js";
+import {
+  getAgentRuntime
+} from "./chunk-RJY45A5J.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  isCoordinatorName,
+  isMultiInstance,
+  shouldAutoInstance
+} from "./chunk-3X2ZT5FN.js";
+
+// src/lib/tasks-notify.ts
+var VERIFY_DELAY_MS = 1e4;
+var ACK_PATTERNS = [
+  /New task assigned/,
+  /START WORKING NOW/,
+  /marked in_progress/,
+  /Reading.*\.md/
+];
+function resolveDispatchRuntime(agentId, override) {
+  if (override) return override;
+  try {
+    return getAgentRuntime(agentId).runtime ?? null;
+  } catch {
+    return null;
+  }
+}
+async function verifyDispatch(sessionName, delayMs = VERIFY_DELAY_MS) {
+  const transport = getTransport();
+  await new Promise((r) => setTimeout(r, delayMs));
+  if (!transport.isAlive(sessionName)) {
+    return "session_dead";
+  }
+  try {
+    const output = transport.capturePane(sessionName, 20);
+    const acked = ACK_PATTERNS.some((p) => p.test(output));
+    return acked ? "verified" : "sent_unverified";
+  } catch {
+    return "sent_unverified";
+  }
+}
+async function dispatchTaskToEmployee(input) {
+  if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
+  const dispatchRuntime = resolveDispatchRuntime(input.assignedTo, input.spawnRuntime);
+  recordOrchestrationEventBestEffort({
+    eventType: "dispatch.attempted",
+    source: "tasks-notify.dispatchTaskToEmployee",
+    taskId: input.taskId ?? null,
+    agentId: input.assignedTo,
+    runtime: dispatchRuntime,
+    payload: { priority: input.priority, projectName: input.projectName }
+  });
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope } = await import("./session-scope-RYBNHQ43.js");
+      const check = assertSessionScope("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          runtime: dispatchRuntime,
+          errorCode: "cross_session_denied",
+          payload: { projectName: input.projectName }
+        });
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.failed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        runtime: dispatchRuntime,
+        errorCode: "no_exe_session"
+      });
+      return { dispatched: "session_missing" };
+    }
+    const multiInstance = isMultiInstance(input.assignedTo);
+    if (multiInstance) {
+      const projectDir = input.projectDir ?? process.cwd();
+      const autoOpts = shouldAutoInstance(input.assignedTo);
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        ...autoOpts,
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "multi_instance", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      const dispatched = result.status === "intercom_sent" || result.status === "intercom_unprocessed" ? "sent_unverified" : "spawned";
+      process.stderr.write(
+        `[dispatch-audit] ${dispatched === "spawned" ? "SPAWNED" : "INTERCOM"} \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "multi_instance", priority: input.priority }
+      });
+      return { dispatched, session: result.sessionName, crossProject };
+    }
+    const sessionName = employeeSessionName(input.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName, { force: true });
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      process.stderr.write(
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "single_instance_intercom", priority: input.priority }
+      });
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "single_instance_spawn", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      process.stderr.write(
+        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: "spawned",
+        payload: { path: "single_instance_spawn", priority: input.priority }
+      });
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } catch {
+    recordOrchestrationEventBestEffort({
+      eventType: "dispatch.failed",
+      source: "tasks-notify.dispatchTaskToEmployee",
+      taskId: input.taskId ?? null,
+      agentId: input.assignedTo,
+      runtime: dispatchRuntime,
+      errorCode: "exception"
+    });
+    return { dispatched: "session_missing" };
+  }
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
+  } catch {
+  }
+}
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+
+export {
+  verifyDispatch,
+  dispatchTaskToEmployee,
+  notifyTaskDone,
+  markTaskNotificationsRead
+};

package/dist/chunk-LIH36DXG.js

@@ -0,0 +1,159 @@
+import {
+  EMBEDDING_DIM
+} from "./chunk-FXU7JOXK.js";
+
+// src/lib/tool-capability-index.ts
+var ALWAYS_ON = /* @__PURE__ */ new Set([
+  "mcp_ping",
+  "memory",
+  "task",
+  "message",
+  "identity",
+  "diagnostics",
+  "session"
+]);
+function categoryForToolName(toolName, categoryMap) {
+  const normalized = toolName.replace(/[_-]/g, "").toLowerCase();
+  for (const [registerFn, cat] of Object.entries(categoryMap)) {
+    const fnNormalized = registerFn.replace(/^register/, "").toLowerCase();
+    if (fnNormalized === normalized) return cat;
+  }
+  return "unknown";
+}
+function extractParamNames(inputSchema) {
+  if (!inputSchema || typeof inputSchema !== "object") return "";
+  return Object.keys(inputSchema).join(", ");
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function keywordScore(query, tool) {
+  const words = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (words.length === 0) return 0;
+  const searchText = `${tool.name} ${tool.description} ${tool.category} ${tool.paramSummary}`.toLowerCase();
+  let matches = 0;
+  for (const word of words) {
+    if (searchText.includes(word)) matches++;
+  }
+  return matches / words.length;
+}
+var ToolCapabilityIndex = class {
+  capabilities = [];
+  initialized = false;
+  /**
+   * Build the index by intercepting registerAllTools via a fake McpServer.
+   *
+   * @param registerFn - function that registers tools on a server (e.g. registerAllTools)
+   * @param categoryMap - optional map of registerFnName → category (from tool-gates TOOL_CATEGORIES)
+   */
+  async buildIndex(registerFn, categoryMap, directEmbedFn) {
+    const captured = [];
+    const fakeServer = {
+      registerTool(name, config, _handler) {
+        captured.push({
+          name,
+          description: config.description ?? "",
+          inputSchema: config.inputSchema ?? {}
+        });
+      }
+    };
+    registerFn(fakeServer);
+    const capabilityDocs = [];
+    for (const tool of captured) {
+      const paramSummary = extractParamNames(tool.inputSchema);
+      const category = categoryMap ? categoryForToolName(tool.name, categoryMap) : "unknown";
+      const doc = `${tool.name}: ${tool.description}. Parameters: ${paramSummary}`;
+      capabilityDocs.push({ name: tool.name, description: tool.description, category, paramSummary, doc });
+    }
+    let vectors = capabilityDocs.map(() => null);
+    try {
+      if (directEmbedFn) {
+        const allVectors = await directEmbedFn(capabilityDocs.map((c) => c.doc));
+        vectors = allVectors.map((v) => v.length === EMBEDDING_DIM ? v : null);
+      } else {
+        const { embed } = await import("./lib/embedder.js");
+        const test = await embed("test");
+        if (test.length === EMBEDDING_DIM) {
+          for (let i = 0; i < capabilityDocs.length; i++) {
+            try {
+              vectors[i] = await embed(capabilityDocs[i].doc);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    const capabilities = capabilityDocs.map((c, i) => ({
+      name: c.name,
+      description: c.description,
+      category: c.category,
+      vector: vectors[i] ?? null,
+      paramSummary: c.paramSummary
+    }));
+    this.capabilities = capabilities;
+    this.initialized = true;
+    process.stderr.write(
+      `[tool-capability-index] Indexed ${capabilities.length} tools (${capabilities.filter((c) => c.vector).length} with vectors)
+`
+    );
+  }
+  /**
+   * Semantic search for tools matching a natural-language query.
+   * Returns tools sorted by relevance, with always-on tools boosted.
+   */
+  async search(query, limit = 20) {
+    if (!this.initialized || this.capabilities.length === 0) return [];
+    let queryVector = null;
+    try {
+      const { embed } = await import("./lib/embedder.js");
+      queryVector = await embed(query);
+    } catch {
+    }
+    const scored = [];
+    for (const tool of this.capabilities) {
+      let relevance;
+      if (queryVector && tool.vector) {
+        const vecScore = cosineSimilarity(queryVector, tool.vector);
+        const kwScore = keywordScore(query, tool);
+        relevance = vecScore * 0.8 + kwScore * 0.2;
+      } else {
+        relevance = keywordScore(query, tool);
+      }
+      if (ALWAYS_ON.has(tool.name)) {
+        relevance = Math.max(relevance, 0.5);
+      }
+      scored.push({ ...tool, relevance });
+    }
+    scored.sort((a, b) => b.relevance - a.relevance);
+    return scored.slice(0, limit);
+  }
+  /** Whether the index has been built. */
+  isReady() {
+    return this.initialized;
+  }
+  /** Total number of indexed tools. */
+  get toolCount() {
+    return this.capabilities.length;
+  }
+};
+var _instance = null;
+function getToolCapabilityIndex() {
+  if (!_instance) {
+    _instance = new ToolCapabilityIndex();
+  }
+  return _instance;
+}
+
+export {
+  ToolCapabilityIndex,
+  getToolCapabilityIndex
+};

package/dist/chunk-M3VHV2RV.js

@@ -0,0 +1,106 @@
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-5P3HOBZX.js";
+
+// src/lib/orchestration-phase.ts
+var ORCHESTRATION_PHASES = [
+  "phase_1_coo",
+  "phase_2_executives",
+  "phase_3_parallel_org"
+];
+var PHASE_INFO = {
+  phase_1_coo: {
+    phase: "phase_1_coo",
+    shortLabel: "Phase 1 \u2014 Coordinator mode",
+    label: "Phase 1 \u2014 Coordinator / Chief of Staff mode",
+    focus: "building company context before delegation",
+    nextSuggestion: "Unlock executives when technical, marketing, ops, legal, or finance work repeats."
+  },
+  phase_2_executives: {
+    phase: "phase_2_executives",
+    shortLabel: "Phase 2 \u2014 Executive bench",
+    label: "Phase 2 \u2014 Executive bench",
+    focus: "Coordinator works with domain executives like CTO/CMO before specialist fan-out",
+    nextSuggestion: "Unlock parallel execution when review gates, permissions, and workflows are ready."
+  },
+  phase_3_parallel_org: {
+    phase: "phase_3_parallel_org",
+    shortLabel: "Phase 3 \u2014 Parallel org",
+    label: "Phase 3 \u2014 Parallel execution org",
+    focus: "executives can delegate to specialists in parallel with review gates",
+    nextSuggestion: "Keep review/CI/permission gates healthy; downgrade anytime if you want simpler coordinator-only mode."
+  }
+};
+function normalizeOrchestrationPhase(input) {
+  if (typeof input !== "string") return "phase_1_coo";
+  const normalized = input.trim().toLowerCase().replace(/\s+/g, "_");
+  if (["1", "phase1", "phase_1", "coo", "coo_mode", "chief_of_staff", "phase_1_coo"].includes(normalized)) {
+    return "phase_1_coo";
+  }
+  if (["2", "phase2", "phase_2", "executives", "executive", "executive_bench", "phase_2_executives"].includes(normalized)) {
+    return "phase_2_executives";
+  }
+  if (["3", "phase3", "phase_3", "parallel", "parallel_org", "parallel_execution", "phase_3_parallel_org"].includes(normalized)) {
+    return "phase_3_parallel_org";
+  }
+  if (ORCHESTRATION_PHASES.includes(normalized)) return normalized;
+  return "phase_1_coo";
+}
+function getOrchestrationPhaseInfo(phase) {
+  return PHASE_INFO[normalizeOrchestrationPhase(phase)];
+}
+function getConfigOrchestrationPhase(config) {
+  const orchestration = config.orchestration;
+  return normalizeOrchestrationPhase(orchestration?.phase);
+}
+function applyDefaultOrchestrationPhase(config) {
+  if (!config.orchestration) {
+    config.orchestration = {
+      phase: "phase_1_coo",
+      phaseSetAt: (/* @__PURE__ */ new Date()).toISOString(),
+      phaseSetBy: "setup-default"
+    };
+    return config;
+  }
+  if (!config.orchestration.phase) {
+    config.orchestration = {
+      ...config.orchestration,
+      phase: "phase_1_coo",
+      phaseSetAt: config.orchestration.phaseSetAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      phaseSetBy: config.orchestration.phaseSetBy ?? "setup-default"
+    };
+  }
+  return config;
+}
+async function loadOrchestrationPhase() {
+  const config = await loadConfig();
+  return getOrchestrationPhaseInfo(config.orchestration?.phase);
+}
+async function setOrchestrationPhase(phaseInput, setBy = "user") {
+  const config = await loadConfig();
+  const phase = normalizeOrchestrationPhase(phaseInput);
+  config.orchestration = {
+    ...config.orchestration ?? {},
+    phase,
+    phaseSetAt: (/* @__PURE__ */ new Date()).toISOString(),
+    phaseSetBy: setBy
+  };
+  await saveConfig(config);
+  return getOrchestrationPhaseInfo(phase);
+}
+function phaseReminderLine(phase) {
+  const info = getOrchestrationPhaseInfo(phase);
+  return `${info.shortLabel}: ${info.focus}. ${info.nextSuggestion}`;
+}
+
+export {
+  ORCHESTRATION_PHASES,
+  normalizeOrchestrationPhase,
+  getOrchestrationPhaseInfo,
+  getConfigOrchestrationPhase,
+  applyDefaultOrchestrationPhase,
+  loadOrchestrationPhase,
+  setOrchestrationPhase,
+  phaseReminderLine
+};