@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-JN44LQ53.js

@@ -0,0 +1,316 @@
+import {
+  init_session_kill_telemetry,
+  recordSessionKill
+} from "./chunk-IHDHL5ML.js";
+import {
+  init_notifications,
+  init_task_scope,
+  init_tmux_routing,
+  sessionScopeFilter,
+  verifyPaneAtCapacity,
+  writeNotification
+} from "./chunk-N7L33TED.js";
+import {
+  init_session_registry,
+  listSessions
+} from "./chunk-KRLOFIPI.js";
+import {
+  getTransport,
+  init_transport
+} from "./chunk-R4M6XCMU.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+import {
+  init_employees,
+  isCoordinatorName
+} from "./chunk-RUG3N6P4.js";
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/capacity-monitor.ts
+function resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
+}
+function buildResumeContext(agentId, openTasks) {
+  const taskList = openTasks.map(
+    (r, i) => `${i + 1}. [${String(r.priority).toUpperCase()}] ${String(r.title)} (${String(r.task_file)})`
+  ).join("\n");
+  return [
+    "## Context",
+    "",
+    `${agentId} hit context capacity and was auto-relaunched by the capacity monitor.`,
+    "Call recall_my_memory first \u2014 search for 'CONTEXT CHECKPOINT'. Pick up where the previous session stopped.",
+    "",
+    `You have ${openTasks.length} open task(s). Work through them in priority order:`,
+    "",
+    taskList,
+    "",
+    "Read each task file and chain through them. Build and commit after each one."
+  ].join("\n");
+}
+function filterPaneContent(paneOutput) {
+  return paneOutput.split("\n").filter((line) => {
+    if (CONTENT_LINE_PREFIX.test(line)) return false;
+    for (const marker of CONTENT_LINE_MARKERS) {
+      if (line.includes(marker)) return false;
+    }
+    for (const re of SOURCE_CODE_MARKERS) {
+      if (re.test(line)) return false;
+    }
+    return true;
+  }).join("\n");
+}
+function extractContextPercent(paneOutput) {
+  const match = paneOutput.match(CC_CONTEXT_BAR_RE);
+  if (!match) return null;
+  const parsed = Number.parseInt(match[2], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isAtCapacity(paneOutput) {
+  const filtered = filterPaneContent(paneOutput);
+  return CAPACITY_PATTERNS.some((p) => p.test(filtered));
+}
+function confirmCapacityKill(agentId, now = Date.now()) {
+  const pendingSince = _pendingCapacityKill.get(agentId);
+  if (pendingSince === void 0) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
+}
+function _resetPendingCapacityKills() {
+  _pendingCapacityKill.clear();
+}
+function _resetLastRelaunchCache() {
+  _lastRelaunch.clear();
+}
+async function lastResumeCreatedAtMs(agentId) {
+  const client = getClient();
+  const cmScope = sessionScopeFilter(null);
+  const result = await client.execute({
+    sql: `SELECT MAX(created_at) AS last_created_at
+          FROM tasks
+          WHERE assigned_to = ? AND title LIKE ?${cmScope.sql}`,
+    args: [agentId, `${RESUME_TITLE_PREFIX} %`, ...cmScope.args]
+  });
+  const raw = result.rows[0]?.last_created_at;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+async function isWithinRelaunchCooldown(agentId, now = Date.now()) {
+  const cached = _lastRelaunch.get(agentId);
+  if (cached !== void 0) return now - cached < RELAUNCH_COOLDOWN_MS;
+  const persisted = await lastResumeCreatedAtMs(agentId);
+  if (persisted === null) return false;
+  if (now - persisted >= RELAUNCH_COOLDOWN_MS) return false;
+  _lastRelaunch.set(agentId, persisted);
+  return true;
+}
+async function createOrRefreshResumeTask(agentId, projectDir, openTasks) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const context = buildResumeContext(agentId, openTasks);
+  const rdScope = sessionScopeFilter(null);
+  const existing = await client.execute({
+    sql: `SELECT id FROM tasks
+          WHERE assigned_to = ?
+            AND title LIKE ?
+            AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})${rdScope.sql}
+          ORDER BY created_at DESC
+          LIMIT 1`,
+    args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES, ...rdScope.args]
+  });
+  if (existing.rows.length > 0) {
+    const taskId = String(existing.rows[0].id);
+    await client.execute({
+      sql: `UPDATE tasks SET context = ?, updated_at = ? WHERE id = ?`,
+      args: [context, now, taskId]
+    });
+    return { created: false, taskId };
+  }
+  const { createTask } = await import("./lib/tasks.js");
+  const task = await createTask({
+    title: resumeTaskTitle(agentId),
+    assignedTo: agentId,
+    assignedBy: "system",
+    projectName: projectDir.split("/").pop() ?? "unknown",
+    priority: "p0",
+    context,
+    baseDir: projectDir
+  });
+  return { created: true, taskId: task.id };
+}
+async function pollCapacityDead() {
+  const transport = getTransport();
+  const relaunched = [];
+  const registered = listSessions().filter(
+    (s) => !isCoordinatorName(s.agentId)
+  );
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = transport.listSessions();
+  } catch {
+    return [];
+  }
+  for (const entry of registered) {
+    const { windowName, agentId, projectDir } = entry;
+    if (!liveSessions.includes(windowName)) continue;
+    if (await isWithinRelaunchCooldown(agentId)) continue;
+    let pane;
+    try {
+      pane = transport.capturePane(windowName, 15);
+    } catch {
+      continue;
+    }
+    if (!isAtCapacity(pane)) continue;
+    const ctxPct = extractContextPercent(pane);
+    if (ctxPct !== null && ctxPct < CTX_FLOOR_PERCENT) {
+      process.stderr.write(
+        `[capacity-monitor] ctx-floor: ${agentId} at ${ctxPct}% in ${windowName} \u2014 below ${CTX_FLOOR_PERCENT}%. Skipping capacity kill (likely self-referential content or false positive).
+`
+      );
+      continue;
+    }
+    if (!confirmCapacityKill(agentId)) {
+      process.stderr.write(
+        `[capacity-monitor] ${agentId} matched capacity pattern once in ${windowName}. Awaiting confirmation on next tick.
+`
+      );
+      continue;
+    }
+    const verify = await verifyPaneAtCapacity(windowName);
+    if (!verify.atCapacity) {
+      process.stderr.write(
+        `[capacity-monitor] verifyPaneAtCapacity rejected kill for ${agentId} in ${windowName} (reason: ${verify.reason}). Skipping.
+`
+      );
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity_false_positive_blocked"
+      });
+      continue;
+    }
+    process.stderr.write(
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
+`
+    );
+    try {
+      transport.kill(windowName);
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity"
+      });
+      const client = getClient();
+      const rlScope = sessionScopeFilter(null);
+      const openTasks = await client.execute({
+        sql: `SELECT id, title, priority, task_file, status
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${rlScope.sql}
+              ORDER BY
+                CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+                created_at ASC
+              LIMIT 10`,
+        args: [agentId, ...rlScope.args]
+      });
+      if (openTasks.rows.length === 0) {
+        process.stderr.write(
+          `[capacity-monitor] ${agentId} has no open tasks \u2014 skipping relaunch.
+`
+        );
+        continue;
+      }
+      const { created } = await createOrRefreshResumeTask(
+        agentId,
+        projectDir,
+        openTasks.rows
+      );
+      if (created) {
+        await writeNotification({
+          agentId: "system",
+          agentRole: "daemon",
+          event: "capacity_relaunch",
+          project: projectDir.split("/").pop() ?? "unknown",
+          summary: `${agentId} hit context capacity. Auto-relaunched with ${openTasks.rows.length} open task(s).`
+        });
+      }
+      _lastRelaunch.set(agentId, Date.now());
+      if (created) relaunched.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[capacity-monitor] Failed to relaunch ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return relaunched;
+}
+var CAPACITY_PATTERNS, CONTENT_LINE_PREFIX, CONTENT_LINE_MARKERS, SOURCE_CODE_MARKERS, RELAUNCH_COOLDOWN_MS, _lastRelaunch, RESUME_TITLE_PREFIX, RESUME_TITLE_LIKE_PATTERN, RESUME_ACTIVE_STATUSES, CONFIRMATION_WINDOW_MS, _pendingCapacityKill, CC_CONTEXT_BAR_RE, CTX_FLOOR_PERCENT;
+var init_capacity_monitor = __esm({
+  "src/lib/capacity-monitor.ts"() {
+    init_session_registry();
+    init_transport();
+    init_notifications();
+    init_database();
+    init_session_kill_telemetry();
+    init_tmux_routing();
+    init_task_scope();
+    init_employees();
+    CAPACITY_PATTERNS = [
+      /conversation is too long/i,
+      /maximum context length/i,
+      /context window.*(?:limit|exceed|full)/i,
+      /reached.*(?:token|context).*limit/i
+    ];
+    CONTENT_LINE_PREFIX = /^[\s>#\-*[]/;
+    CONTENT_LINE_MARKERS = [
+      "RESUME:",
+      "intercom",
+      "capacity-monitor",
+      "CAPACITY_PATTERNS",
+      "isAtCapacity",
+      "CONTENT_LINE_MARKERS",
+      "pollCapacityDead",
+      "confirmCapacityKill",
+      "session_kills",
+      "capacity-monitor.test"
+    ];
+    SOURCE_CODE_MARKERS = [
+      /["'`/].*(?:maximum context length|conversation is too long)/i,
+      /(?:maximum context length|conversation is too long).*["'`/]/i
+    ];
+    RELAUNCH_COOLDOWN_MS = 5 * 60 * 1e3;
+    _lastRelaunch = /* @__PURE__ */ new Map();
+    RESUME_TITLE_PREFIX = "RESUME:";
+    RESUME_TITLE_LIKE_PATTERN = `${RESUME_TITLE_PREFIX} % hit context capacity%`;
+    RESUME_ACTIVE_STATUSES = ["open", "in_progress"];
+    CONFIRMATION_WINDOW_MS = 3 * 60 * 1e3;
+    _pendingCapacityKill = /* @__PURE__ */ new Map();
+    CC_CONTEXT_BAR_RE = /([\u2588\u2591\u2592\u2593]{10})\s+(\d+)%/;
+    CTX_FLOOR_PERCENT = 50;
+  }
+});
+
+export {
+  CTX_FLOOR_PERCENT,
+  extractContextPercent,
+  isAtCapacity,
+  confirmCapacityKill,
+  _resetPendingCapacityKills,
+  _resetLastRelaunchCache,
+  isWithinRelaunchCooldown,
+  createOrRefreshResumeTask,
+  pollCapacityDead,
+  init_capacity_monitor
+};

package/dist/chunk-JQ6TLNIV.js

@@ -0,0 +1,133 @@
+import {
+  checkPermission
+} from "./chunk-PRKVT4KN.js";
+
+// src/runtime/zod-to-schema.ts
+function zodToJsonSchema(schema) {
+  if ("toJSONSchema" in schema && typeof schema.toJSONSchema === "function") {
+    return schema.toJSONSchema();
+  }
+  const def = schema._def;
+  if (!def) {
+    return { type: "object", properties: {} };
+  }
+  return extractSchema(def);
+}
+function extractSchema(def) {
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodObject": {
+      const shape = def.shape;
+      const properties = {};
+      const required = [];
+      if (shape) {
+        const resolved = typeof shape === "function" ? shape() : shape;
+        for (const [key, value] of Object.entries(resolved)) {
+          const fieldDef = value._def ?? value;
+          const isOptional = fieldDef.typeName === "ZodOptional";
+          if (isOptional) {
+            properties[key] = extractSchema(
+              fieldDef.innerType?._def ?? {}
+            );
+          } else {
+            properties[key] = extractSchema(fieldDef);
+            required.push(key);
+          }
+        }
+      }
+      const result = { type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+    case "ZodString":
+      return { type: "string", ...def.description ? { description: String(def.description) } : {} };
+    case "ZodNumber":
+      return { type: "number", ...def.description ? { description: String(def.description) } : {} };
+    case "ZodBoolean":
+      return { type: "boolean", ...def.description ? { description: String(def.description) } : {} };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: extractSchema(
+          def.type?._def ?? {}
+        )
+      };
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    case "ZodOptional":
+      return extractSchema(
+        def.innerType?._def ?? {}
+      );
+    case "ZodDefault":
+      return extractSchema(
+        def.innerType?._def ?? {}
+      );
+    default:
+      return { type: "string" };
+  }
+}
+
+// src/runtime/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  /** Register a tool */
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /** Look up a tool by name */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** List all registered tools */
+  list() {
+    return [...this.tools.values()];
+  }
+  /** List tool names */
+  names() {
+    return [...this.tools.keys()];
+  }
+  /** Convert all tools to LLM-ready NormalizedTool format */
+  toNormalizedTools() {
+    return this.list().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: zodToJsonSchema(tool.inputSchema)
+    }));
+  }
+  /** Get only tools allowed by the given permission set */
+  listAllowed(permissions) {
+    return this.list().filter(
+      (tool) => checkPermission(tool.name, permissions).allowed
+    );
+  }
+  /** Convert allowed tools to NormalizedTool format */
+  toAllowedNormalizedTools(permissions) {
+    return this.listAllowed(permissions).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: zodToJsonSchema(tool.inputSchema)
+    }));
+  }
+};
+function partitionTools(blocks, registry) {
+  const concurrent = [];
+  const sequential = [];
+  let hitWrite = false;
+  for (const block of blocks) {
+    if (block.type !== "tool_use") continue;
+    const tool = registry.get(block.name);
+    if (!hitWrite && tool?.isReadOnly) {
+      concurrent.push(block);
+    } else {
+      hitWrite = true;
+      sequential.push(block);
+    }
+  }
+  return { concurrent, sequential };
+}
+
+export {
+  zodToJsonSchema,
+  ToolRegistry,
+  partitionTools
+};

package/dist/chunk-JT76KRZQ.js

@@ -0,0 +1,35 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "interactive",
+        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.5"
+      },
+      opencode: {
+        binary: "opencode",
+        launchMode: "exec",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        inlineFlag: "",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        defaultModel: "anthropic/claude-sonnet-4-6"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+export {
+  RUNTIME_TABLE,
+  DEFAULT_RUNTIME,
+  init_runtime_table
+};