@askexenow/exe-os 0.9.341 → 0.9.343

package/dist/chunk-VIIHBYIP.js

@@ -0,0 +1,335 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-OL4JFQ2T.js";
+
+// src/lib/memory-queue.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  unlinkSync,
+  existsSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+import crypto from "crypto";
+var QUEUE_PATH = path.join(EXE_AI_DIR, "memory-queue.jsonl");
+var PROCESSING_PATH = QUEUE_PATH + ".processing";
+var PROCESSING_PREFIX = path.basename(PROCESSING_PATH);
+var TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_STALE_LEASE_MS = 5 * 60 * 1e3;
+function enqueueMemory(entry) {
+  mkdirSync(path.dirname(QUEUE_PATH), { recursive: true });
+  appendFileSync(QUEUE_PATH, JSON.stringify(entry) + "\n");
+}
+function claimQueue(options = {}) {
+  const staleLeaseMs = options.staleLeaseMs ?? DEFAULT_STALE_LEASE_MS;
+  const staleLease = claimStaleLease(staleLeaseMs);
+  if (staleLease) return staleLease;
+  if (!existsSync(QUEUE_PATH)) return null;
+  try {
+    const stat = statSync(QUEUE_PATH);
+    if (stat.size === 0) {
+      try {
+        unlinkSync(QUEUE_PATH);
+      } catch {
+      }
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const leasePath = newLeasePath();
+  try {
+    renameSync(QUEUE_PATH, leasePath);
+  } catch {
+    return null;
+  }
+  const entries = parseQueueFile(leasePath);
+  if (entries.length === 0) {
+    try {
+      unlinkSync(leasePath);
+    } catch {
+    }
+    return null;
+  }
+  return { leasePath, entries };
+}
+function ackQueue(leasePath) {
+  assertQueueLeasePath(leasePath);
+  try {
+    unlinkSync(leasePath);
+  } catch {
+  }
+}
+function retryQueueEntries(leasePath, entries) {
+  assertQueueLeasePath(leasePath);
+  if (entries.length === 0) {
+    ackQueue(leasePath);
+    return;
+  }
+  writeFileSync(leasePath, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+}
+async function processQueueEntries(entries, writeEntry, options = {}) {
+  const batchSize = Math.max(1, options.batchSize ?? 1);
+  const yieldFn = options.yieldFn ?? (() => new Promise((resolve) => setImmediate(resolve)));
+  const isDraining = options.isDraining ?? (() => false);
+  const retryEntries = [];
+  let processed = 0;
+  let preserved = 0;
+  let sinceYield = 0;
+  const hasBatchHooks = Boolean(options.beginBatch && options.commitBatch && options.rollbackBatch);
+  if (hasBatchHooks) {
+    const beginBatch = options.beginBatch;
+    const commitBatch = options.commitBatch;
+    const rollbackBatch = options.rollbackBatch;
+    const maxBatchMs = Math.max(1, options.maxBatchMs ?? 500);
+    let i = 0;
+    while (i < entries.length) {
+      while (i < entries.length && !isWritableEntry(entries[i])) i++;
+      if (i >= entries.length) break;
+      if (isDraining()) {
+        const remaining = entries.slice(i).filter(isWritableEntry);
+        retryEntries.push(...remaining);
+        preserved += remaining.length;
+        if (remaining.length > 0) options.onShutdownPreserve?.(remaining.length);
+        break;
+      }
+      const written = [];
+      let transactionOpen = false;
+      try {
+        await beginBatch();
+        transactionOpen = true;
+        const txStartedAt = Date.now();
+        while (i < entries.length && written.length < batchSize) {
+          const entry = entries[i];
+          if (!isWritableEntry(entry)) {
+            i++;
+            continue;
+          }
+          if (isDraining()) {
+            await rollbackBatch();
+            transactionOpen = false;
+            const remaining = [...written, ...entries.slice(i).filter(isWritableEntry)];
+            retryEntries.push(...remaining);
+            preserved += remaining.length;
+            if (remaining.length > 0) options.onShutdownPreserve?.(remaining.length);
+            return { processed, retryEntries, preserved };
+          }
+          await writeEntry(entry);
+          written.push(entry);
+          i++;
+          if (Date.now() - txStartedAt >= maxBatchMs) break;
+        }
+        await commitBatch();
+        transactionOpen = false;
+        processed += written.length;
+        await yieldFn();
+      } catch {
+        if (transactionOpen) {
+          try {
+            await rollbackBatch();
+          } catch {
+          }
+        }
+        const failedEntry = i < entries.length ? entries[i] : void 0;
+        const toReprocess = [...written];
+        if (failedEntry && isWritableEntry(failedEntry)) {
+          toReprocess.push(failedEntry);
+        }
+        if (failedEntry) i++;
+        const individual = await processIndividualEntries(
+          toReprocess,
+          writeEntry,
+          {
+            isDraining,
+            onWriteError: options.onWriteError,
+            onShutdownPreserve: options.onShutdownPreserve
+          }
+        );
+        processed += individual.processed;
+        retryEntries.push(...individual.retryEntries);
+        preserved += individual.preserved;
+        if (individual.preserved > 0) {
+          const remaining = entries.slice(i).filter(isWritableEntry);
+          retryEntries.push(...remaining);
+          preserved += remaining.length;
+          if (remaining.length > 0) options.onShutdownPreserve?.(remaining.length);
+          break;
+        }
+        await yieldFn();
+      }
+    }
+    return { processed, retryEntries, preserved };
+  }
+  for (let i = 0; i < entries.length; i++) {
+    if (isDraining()) {
+      const remaining = entries.slice(i).filter(isWritableEntry);
+      retryEntries.push(...remaining);
+      preserved = remaining.length;
+      if (preserved > 0) options.onShutdownPreserve?.(preserved);
+      break;
+    }
+    const entry = entries[i];
+    if (!isWritableEntry(entry)) continue;
+    try {
+      await writeEntry(entry);
+      processed++;
+    } catch (err) {
+      retryEntries.push(entry);
+      options.onWriteError?.(entry, err);
+    }
+    if (++sinceYield >= batchSize) {
+      sinceYield = 0;
+      await yieldFn();
+    }
+  }
+  return { processed, retryEntries, preserved };
+}
+function isWritableEntry(entry) {
+  return Boolean(entry.raw_text && entry.raw_text.length >= 10);
+}
+async function processIndividualEntries(entries, writeEntry, options) {
+  const isDraining = options.isDraining ?? (() => false);
+  const retryEntries = [];
+  let processed = 0;
+  let preserved = 0;
+  for (let i = 0; i < entries.length; i++) {
+    if (isDraining()) {
+      const remaining = entries.slice(i).filter(isWritableEntry);
+      retryEntries.push(...remaining);
+      preserved = remaining.length;
+      if (preserved > 0) options.onShutdownPreserve?.(preserved);
+      break;
+    }
+    const entry = entries[i];
+    if (!isWritableEntry(entry)) continue;
+    try {
+      await writeEntry(entry);
+      processed++;
+    } catch (err) {
+      retryEntries.push(entry);
+      options.onWriteError?.(entry, err);
+    }
+  }
+  return { processed, retryEntries, preserved };
+}
+function drainQueue() {
+  const entries = [];
+  while (true) {
+    const lease = claimQueue({ staleLeaseMs: 0 });
+    if (!lease) break;
+    entries.push(...lease.entries);
+    ackQueue(lease.leasePath);
+  }
+  return entries;
+}
+function queueDepth() {
+  const queueFiles = [QUEUE_PATH, ...listLeasePaths()];
+  let count = 0;
+  for (const filePath of queueFiles) {
+    if (!existsSync(filePath)) continue;
+    try {
+      const content = readFileSync(filePath, "utf8");
+      count += content.split("\n").filter((line) => line.trim().length > 0).length;
+    } catch {
+    }
+  }
+  return count;
+}
+function newLeasePath() {
+  const unique = `${process.pid}.${Date.now()}.${crypto.randomBytes(6).toString("hex")}`;
+  return `${PROCESSING_PATH}.${unique}`;
+}
+function listLeasePaths() {
+  const dir = path.dirname(QUEUE_PATH);
+  const files = [];
+  try {
+    for (const name of readdirSync(dir)) {
+      if (name === PROCESSING_PREFIX || name.startsWith(`${PROCESSING_PREFIX}.`)) {
+        files.push(path.join(dir, name));
+      }
+    }
+  } catch {
+  }
+  return files.sort();
+}
+function claimStaleLease(staleLeaseMs) {
+  const now = Date.now();
+  for (const existingLeasePath of listLeasePaths()) {
+    let stat;
+    try {
+      stat = statSync(existingLeasePath);
+    } catch {
+      continue;
+    }
+    const ageMs = Math.max(0, now - stat.mtimeMs);
+    if (ageMs < staleLeaseMs) continue;
+    let leasePath = existingLeasePath;
+    if (path.basename(existingLeasePath) === PROCESSING_PREFIX) {
+      leasePath = newLeasePath();
+      try {
+        renameSync(existingLeasePath, leasePath);
+      } catch {
+        continue;
+      }
+    }
+    const entries = parseQueueFile(leasePath);
+    if (entries.length === 0) {
+      try {
+        unlinkSync(leasePath);
+      } catch {
+      }
+      continue;
+    }
+    return { leasePath, entries };
+  }
+  return null;
+}
+function assertQueueLeasePath(leasePath) {
+  const resolved = path.resolve(leasePath);
+  const dir = path.resolve(path.dirname(QUEUE_PATH));
+  const base = path.basename(resolved);
+  if (path.dirname(resolved) !== dir || base !== PROCESSING_PREFIX && !base.startsWith(`${PROCESSING_PREFIX}.`)) {
+    throw new Error(`Refusing to operate on non-memory-queue lease path: ${leasePath}`);
+  }
+}
+function parseQueueFile(filePath) {
+  const now = Date.now();
+  const entries = [];
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return entries;
+  }
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.timestamp) {
+        const age = now - new Date(entry.timestamp).getTime();
+        if (age > TTL_MS) continue;
+      }
+      entries.push(entry);
+    } catch {
+      process.stderr.write(`[memory-queue] Skipping corrupt line: ${trimmed.slice(0, 80)}
+`);
+    }
+  }
+  return entries;
+}
+
+export {
+  enqueueMemory,
+  claimQueue,
+  ackQueue,
+  retryQueueEntries,
+  processQueueEntries,
+  drainQueue,
+  queueDepth
+};

package/dist/{chunk-54QCG45Y.js → chunk-WOYADZF5.js}

@@ -3,7 +3,8 @@ import {
 } from "./chunk-GJV3WDWM.js";
 
 // src/lib/tmux-transport.ts
-import { execFileSync } from "child_process";
+import { execFile, execFileSync } from "child_process";
+import { promisify } from "util";
 import { writeFileSync, unlinkSync, mkdirSync } from "fs";
 import { randomBytes } from "crypto";
 import path from "path";
@@ -24,6 +25,7 @@ var QUIET = {
   stdio: ["pipe", "pipe", "pipe"],
   timeout: 3e3
 };
+var execFileAsync = promisify(execFile);
 var TmuxTransport = class {
   sessionsCache = { ts: 0, sessions: [] };
   paneStatusCache = { ts: 0, bySession: /* @__PURE__ */ new Map(), byPaneId: /* @__PURE__ */ new Map() };
@@ -68,12 +70,30 @@ var TmuxTransport = class {
     this.paneStatusCache = { ts: now, bySession, byPaneId };
     return this.paneStatusCache;
   }
+  /**
+   * The tmux session this PROCESS lives in. Immutable for the process lifetime
+   * (a process cannot move between sessions), so it is resolved once and
+   * memoized — unlike listSessions/paneStatus, which describe the changing
+   * outside world and keep their TTL caches.
+   *
+   * Boot-perf (bug 4b2d2d10): this was an uncached fork on EVERY call. Every
+   * sessionScopeFilter() → resolveExeSession() → getMySession() hop paid a
+   * `tmux display-message` fork — 9.95s of a 76s boot, most of it from inside
+   * per-task loops. Memoizing removes the forks without changing the answer.
+   * Deliberately NOT cleared by invalidateCaches(): spawning or killing another
+   * session cannot rename the session we are in.
+   */
+  mySessionCache = { resolved: false, value: null };
   getMySession() {
+    if (this.mySessionCache.resolved) return this.mySessionCache.value;
+    let value = null;
     try {
-      return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
+      value = execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
     } catch {
-      return null;
+      value = null;
     }
+    this.mySessionCache = { resolved: true, value };
+    return value;
   }
   listSessions() {
     return this.listSessionsCached();
@@ -164,7 +184,18 @@ var TmuxTransport = class {
       return { sessionName: name, error: `spawn failed: ${e}` };
     }
   }
-  kill(target, callerScope) {
+  /**
+   * Session-isolation guard shared by the sync kill and the async killAsync.
+   * Returns true when the kill is BLOCKED (caller scope ≠ target scope).
+   *
+   * Session isolation: only kill sessions belonging to the caller's coordinator
+   * scope. An agent in exe1 can only kill *-exe1 sessions. Coordinator sessions
+   * (exe1) can kill their own employees.
+   *
+   * Caller identity priority (bug a671b0c9): explicit callerScope → ALS
+   * sessionHint/EXE_SESSION → ambient tmux.
+   */
+  killBlockedByScope(target, callerScope) {
     const resolvedCaller = this.resolveCallerScope(callerScope);
     if (resolvedCaller && target.includes("-")) {
       const targetScope = target.slice(target.lastIndexOf("-") + 1);
@@ -174,15 +205,35 @@ var TmuxTransport = class {
           `[tmux-transport] BLOCKED kill: caller scope "${resolvedCaller}" tried to kill ${target} (scope ${targetScope} \u2260 ${cScope}). Session isolation enforced.
 `
         );
-        return;
+        return true;
       }
     }
+    return false;
+  }
+  kill(target, callerScope) {
+    if (this.killBlockedByScope(target, callerScope)) return;
     try {
       execFileSync("tmux", ["kill-session", "-t", target], QUIET);
     } catch {
     }
     this.invalidateCaches();
   }
+  /**
+   * Async twin of kill — same isolation guard, but the actual kill-session runs
+   * via execFileAsync so it never blocks the event loop. Bug 1c870c78: the
+   * daemon's 5-min TTL timer kills expired sessions through deps.killSession →
+   * kill → execFileSync; on kill decisions that was a sync tmux subprocess on
+   * the timer. The TTL real deps now await this. Sync kill() is kept for the
+   * many non-timer callers (no ripple).
+   */
+  async killAsync(target, callerScope) {
+    if (this.killBlockedByScope(target, callerScope)) return;
+    try {
+      await execFileAsync("tmux", ["kill-session", "-t", target], { encoding: "utf8", timeout: 3e3 });
+    } catch {
+    }
+    this.invalidateCaches();
+  }
   /**
    * Resolve the caller's coordinator scope for isolation enforcement.
    * In the shared HTTP daemon, ambient tmux is meaningless — prefer the

package/dist/{chunk-GFDGDFBF.js → chunk-WYRZEMRU.js}

@@ -1,14 +1,19 @@
+import {
+  assertCodexModelForAuth,
+  describeCodexModelAvailability,
+  detectCodexAuthType
+} from "./chunk-AM7S2TY6.js";
 import {
   DEFAULT_RUNTIME,
   RUNTIME_TABLE
 } from "./chunk-NGP6LSV2.js";
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-OL4JFQ2T.js";
 import {
   atomicWriteJsonSync,
   ensurePrivateDirSync
-} from "./chunk-SHIICYJW.js";
+} from "./chunk-BYTDMAGB.js";
 
 // src/lib/agent-config.ts
 import { readFileSync, existsSync } from "fs";
@@ -16,6 +21,14 @@ import path from "path";
 var AGENT_CONFIG_PATH = path.join(EXE_AI_DIR, "agent-config.json");
 var KNOWN_RUNTIMES = {
   claude: ["claude-opus-4.8", "claude-opus-4.8-1m", "claude-opus-4.6", "claude-sonnet-4.8", "claude-sonnet-4.6", "claude-haiku-4.5", "claude-fable-5"],
+  // Bug fbf99272: this list MUST contain RUNTIME_TABLE.codex.defaultModel — the
+  // adapter's own default — or a default codex spawn boots an unlisted model that
+  // 400s and idles (asserted by an agent-config-models test so they cannot drift).
+  // Codex model availability also depends on AUTH TYPE (ChatGPT account vs OpenAI
+  // API key); see codex-auth.ts for the auth-aware preflight. Do NOT add
+  // "gpt-5.6" here: VERIFIED 2026-07-10 to 400 ("not supported … with a ChatGPT
+  // account"). "gpt-5.3-codex" (the Codex CLI's own default) is likewise NOT
+  // whitelisted for the same reason — exe-start-codex pins a listed model instead.
   codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
   opencode: ["anthropic/claude-opus-4-8", "anthropic/claude-sonnet-4-8", "anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5", "xai/grok-4", "xai/grok-3", "xai/grok-2-latest", "xai/grok-2-1212", "xai/grok-beta"]
 };
@@ -125,7 +138,7 @@ function resolveSpawnRuntimeConfig(agentId, runtimeOverride, modelOverride) {
     ...modelOverride ? { model: modelOverride } : {}
   };
 }
-function assertRuntimeModelCompatible(runtime, model) {
+function assertRuntimeModelCompatible(runtime, model, opts) {
   const replacement = retiredModelReplacement(model);
   if (replacement) {
     return {
@@ -134,12 +147,16 @@ function assertRuntimeModelCompatible(runtime, model) {
     };
   }
   if (runtime === "codex" && model && isClaudeModel(model)) {
-    const codexModels = KNOWN_RUNTIMES.codex?.join(", ") ?? "gpt-* models";
     return {
       ok: false,
-      error: `Runtime/model mismatch: runtime "codex" cannot run Claude model "${model}". Codex (ChatGPT account) only supports OpenAI models (${codexModels}). Pass a Codex spawn_model, or set the agent's runtime to "claude". Rejected before spawn to avoid a silently dead session (bug a403e1f4).`
+      error: `Runtime/model mismatch: runtime "codex" cannot run Claude model "${model}". Codex needs an OpenAI model (${describeCodexModelAvailability(KNOWN_RUNTIMES.codex ?? [])}). Pass a Codex spawn_model, or set the agent's runtime to "claude". Rejected before spawn to avoid a silently dead session (bug a403e1f4).`
     };
   }
+  if (runtime === "codex" && model) {
+    const authType = opts?.codexAuthType ?? detectCodexAuthType();
+    const authCheck = assertCodexModelForAuth(model, authType, KNOWN_RUNTIMES.codex ?? []);
+    if (!authCheck.ok) return authCheck;
+  }
   if (model && KNOWN_RUNTIMES[runtime]) {
     const validated = validateRuntimeModel(runtime, model);
     if (!validated.ok) {