@mutmutco/cli 2.57.0 → 2.58.0

package/dist/main.cjs

@@ -10282,8 +10282,10 @@ var OVERLORD_DEFAULT_ENGINE = "fugu-api";
 var FUGU_API_DEFAULT_BASE_URL = "https://api.sakana.ai/v1";
 var FUGU_API_DEFAULT_MODEL = "fugu";
 var FUGU_API_DEFAULT_ULTRA_MODEL = "fugu-ultra";
-var FUGU_API_DEFAULT_TIMEOUT_MS = 9e4;
+var FUGU_API_DEFAULT_TIMEOUT_MS = 48e4;
 var FUGU_API_DEFAULT_STARTUP_TIMEOUT_MS = 45e3;
+var FUGU_API_DEFAULT_IDLE_MS = 6e4;
+var FUGU_API_DEFAULT_MAX_TOKENS = 16e3;
 var FUGU_API_DEFAULT_MAX_ATTEMPTS = 3;
 var FUGU_API_RETRY_BASE_MS = 250;
 var FUGU_API_RETRY_CAP_MS = 8e3;
@@ -10493,6 +10495,81 @@ function writeOverlordRegistry(statePath, registry2) {
   atomicWriteFileSync(statePath, `${JSON.stringify(registry2, null, 2)}
 `);
 }
+function sleepSyncMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(1, ms));
+}
+var OVERLORD_REGISTRY_LOCK_TIMEOUT_MS = 5e3;
+var OVERLORD_REGISTRY_LOCK_STALE_MS = 3e4;
+function withRegistryLock(statePath, fn) {
+  const lockPath = `${statePath}.lock`;
+  (0, import_node_fs15.mkdirSync)((0, import_node_path13.dirname)(statePath), { recursive: true });
+  const deadline = Date.now() + OVERLORD_REGISTRY_LOCK_TIMEOUT_MS;
+  let fd;
+  for (; ; ) {
+    try {
+      fd = (0, import_node_fs15.openSync)(lockPath, "wx");
+      break;
+    } catch {
+      let stale = false;
+      try {
+        stale = Date.now() - (0, import_node_fs15.statSync)(lockPath).mtimeMs > OVERLORD_REGISTRY_LOCK_STALE_MS;
+      } catch {
+        stale = false;
+      }
+      if (stale) {
+        try {
+          (0, import_node_fs15.rmSync)(lockPath, { force: true });
+        } catch {
+        }
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error(`Overlord registry lock is busy: ${lockPath}`);
+      sleepSyncMs(25);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (fd !== void 0) (0, import_node_fs15.closeSync)(fd);
+    try {
+      (0, import_node_fs15.rmSync)(lockPath, { force: true });
+    } catch {
+    }
+  }
+}
+function persistRunMutation(statePath, runId, mutate) {
+  return withRegistryLock(statePath, () => {
+    const fresh = readOverlordRegistry(statePath);
+    const current = fresh.runs[runId];
+    if (!current) throw new Error(`Overlord run ${runId} is no longer in the registry`);
+    const next = mutate(current);
+    writeOverlordRegistry(statePath, { ...fresh, runs: { ...fresh.runs, [runId]: next } });
+    return next;
+  });
+}
+function resolveOverlordSendMessage(messageArgs, messageFile) {
+  const inline = messageArgs.join(" ").trim();
+  if (inline) return inline;
+  if (messageFile) {
+    const raw = messageFile === "-" ? (0, import_node_fs15.readFileSync)(0, "utf8") : (0, import_node_fs15.readFileSync)(messageFile, "utf8");
+    return raw.trim();
+  }
+  return "";
+}
+function computeAffectedSlots(servants, normalized, settled) {
+  const targetSlots = normalized === "all" ? servants.map((s) => s.slotId) : servants.filter((s) => s.slotId === normalized || normalizeServantTarget(s.name) === normalized).map((s) => s.slotId);
+  return /* @__PURE__ */ new Set([...(settled?.servantResults ?? []).map((r) => r.slotId), ...targetSlots]);
+}
+function mergeConcurrentDispatch(fresh, dispatched, settled, affected, messageId) {
+  const dispatchedBySlot = new Map(dispatched.servants.map((s) => [s.slotId, s]));
+  const updatedAt = [fresh.updatedAt, dispatched.updatedAt].filter(Boolean).sort().at(-1) ?? dispatched.updatedAt;
+  return {
+    ...fresh,
+    updatedAt,
+    servants: fresh.servants.map((s) => affected.has(s.slotId) ? dispatchedBySlot.get(s.slotId) ?? s : s),
+    messages: [...(fresh.messages ?? []).filter((m) => m.id !== messageId), ...settled ? [settled] : []]
+  };
+}
 function buildOverlordRun(options) {
   const runId = options.runId?.() ?? defaultRunId();
   const runToken = options.runToken?.() ?? defaultRunToken();
@@ -10603,8 +10680,18 @@ function defaultKillPid(pid) {
 function fuguApiTimeoutMs() {
   const parsed = Number(process.env.MMI_OVERLORD_LLM_TIMEOUT_MS);
   if (!Number.isFinite(parsed) || parsed <= 0) return FUGU_API_DEFAULT_TIMEOUT_MS;
+  return Math.min(Math.max(Math.trunc(parsed), 5e3), 12e5);
+}
+function fuguApiIdleMs() {
+  const parsed = Number(process.env.MMI_OVERLORD_LLM_IDLE_MS);
+  if (!Number.isFinite(parsed) || parsed <= 0) return FUGU_API_DEFAULT_IDLE_MS;
   return Math.min(Math.max(Math.trunc(parsed), 5e3), 6e5);
 }
+function fuguApiMaxTokens() {
+  const parsed = Number(process.env.MMI_OVERLORD_LLM_MAX_TOKENS);
+  if (!Number.isFinite(parsed) || parsed <= 0) return FUGU_API_DEFAULT_MAX_TOKENS;
+  return Math.min(Math.max(Math.trunc(parsed), 256), 2e5);
+}
 function fuguApiStartupTimeoutMs() {
   const workTimeout = fuguApiTimeoutMs();
   const parsed = Number(process.env.MMI_OVERLORD_LLM_STARTUP_TIMEOUT_MS);
@@ -10617,7 +10704,9 @@ function fuguApiConfig() {
     apiKey: process.env.MMI_OVERLORD_LLM_API_KEY ?? process.env.SAKANA_API_KEY,
     model: process.env.MMI_OVERLORD_LLM_MODEL ?? FUGU_API_DEFAULT_MODEL,
     ultraModel: process.env.MMI_OVERLORD_LLM_ULTRA_MODEL ?? FUGU_API_DEFAULT_ULTRA_MODEL,
-    timeoutMs: fuguApiTimeoutMs()
+    timeoutMs: fuguApiTimeoutMs(),
+    idleMs: fuguApiIdleMs(),
+    maxTokens: fuguApiMaxTokens()
   };
 }
 function fuguApiModelForServant(config, servant) {
@@ -10685,6 +10774,37 @@ function mapFuguApiUsage(usage) {
   };
   return Object.values(mapped).some((value) => typeof value === "number") ? mapped : void 0;
 }
+function buildFuguRequestBody(model, messages, maxTokens) {
+  return {
+    model,
+    messages,
+    temperature: 0.2,
+    max_tokens: maxTokens,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+}
+function foldFuguSse(payloads) {
+  let text = "";
+  let finishReason;
+  let rawUsage;
+  for (const payload of payloads) {
+    const data = payload.trim();
+    if (!data || data === "[DONE]") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      continue;
+    }
+    const choice = parsed?.choices?.[0];
+    const piece = choice?.delta?.content ?? choice?.message?.content;
+    if (typeof piece === "string") text += piece;
+    if (choice?.finish_reason) finishReason = choice.finish_reason;
+    if (parsed?.usage) rawUsage = parsed.usage;
+  }
+  return { text, finishReason, usage: mapFuguApiUsage(rawUsage) };
+}
 async function defaultRunFuguApi(run, servant, message, options) {
   const config = fuguApiConfig();
   if (!config.apiKey) return { ok: false, error: "SAKANA_API_KEY or MMI_OVERLORD_LLM_API_KEY is not available" };
@@ -10693,8 +10813,24 @@ async function defaultRunFuguApi(run, servant, message, options) {
     ...servant.llmMessages ?? [{ role: "system", content: fuguApiSystemMessage(servant, run) }],
     { role: "user", content: message }
   ];
+  const totalMs = options?.timeoutMs ?? config.timeoutMs;
+  const idleMs = Math.min(config.idleMs, totalMs);
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), options?.timeoutMs ?? config.timeoutMs);
+  let abortKind;
+  const totalTimer = setTimeout(() => {
+    abortKind = "total";
+    controller.abort();
+  }, totalMs);
+  let idleTimer;
+  let streamReader;
+  const armIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      abortKind = "idle";
+      controller.abort();
+    }, idleMs);
+  };
+  armIdle();
   try {
     const response = await fetch(`${config.baseUrl}/chat/completions`, {
       method: "POST",
@@ -10702,44 +10838,71 @@ async function defaultRunFuguApi(run, servant, message, options) {
         Authorization: `Bearer ${config.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({
-        model,
-        messages,
-        temperature: 0.2
-      }),
+      body: JSON.stringify(buildFuguRequestBody(model, messages, config.maxTokens)),
       signal: controller.signal
     });
     const requestId = response.headers.get("x-request-id") ?? response.headers.get("request-id") ?? void 0;
-    const json = await response.json().catch(() => void 0);
     if (!response.ok) {
+      const errBody = await response.json().catch(() => void 0);
       return {
         ok: false,
         model,
         requestId,
-        error: json?.error?.message ?? `Fugu API returned HTTP ${response.status}`,
+        error: errBody?.error?.message ?? `Fugu API returned HTTP ${response.status}`,
         retryable: response.status === 429 || response.status >= 500
       };
     }
-    const text = json?.choices?.[0]?.message?.content?.trim() ?? "";
-    if (!text) return { ok: false, model, requestId, error: "Fugu API returned no assistant text" };
+    if (!response.body) return { ok: false, model, requestId, error: "Fugu API returned no response body", retryable: true };
+    const reader = response.body.getReader();
+    streamReader = reader;
+    const decoder = new TextDecoder();
+    const payloads = [];
+    let buffer = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      armIdle();
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data:")) payloads.push(trimmed.slice(5).trim());
+      }
+    }
+    const tail = buffer.trim();
+    if (tail.startsWith("data:")) payloads.push(tail.slice(5).trim());
+    const { text: rawText, finishReason, usage } = foldFuguSse(payloads);
+    const text = rawText.trim();
+    if (!text) {
+      const reason = finishReason === "length" ? "Fugu API hit max_tokens before emitting content (raise MMI_OVERLORD_LLM_MAX_TOKENS)" : "Fugu API returned no assistant text";
+      return { ok: false, model, requestId, error: reason, finishReason, usage, retryable: false };
+    }
     return {
       ok: true,
       text,
       model,
       requestId,
-      usage: mapFuguApiUsage(json?.usage),
+      finishReason,
+      usage,
       messages: [...messages, { role: "assistant", content: text }]
     };
   } catch (e) {
     const aborted = e instanceof Error && e.name === "AbortError";
-    return {
-      ok: false,
-      model,
-      error: aborted ? "Fugu API request timed out" : e instanceof Error ? e.message : String(e),
-      retryable: true
-    };
+    if (aborted) {
+      const bound = abortKind === "idle" ? `${Math.round(idleMs / 1e3)}s with no data` : `${Math.round(totalMs / 1e3)}s total`;
+      return { ok: false, model, error: `Fugu API request timed out (${bound})`, retryable: false };
+    }
+    return { ok: false, model, error: e instanceof Error ? e.message : String(e), retryable: true };
   } finally {
-    clearTimeout(timeout);
+    clearTimeout(totalTimer);
+    if (idleTimer) clearTimeout(idleTimer);
+    if (streamReader) {
+      try {
+        streamReader.releaseLock();
+      } catch {
+      }
+    }
   }
 }
 function renderOverlordPreflightFailure(report) {
@@ -10935,18 +11098,44 @@ function hasServantTarget(run, target) {
     (servant) => servant.slotId === normalized || normalizeServantTarget(servant.name) === normalized
   );
 }
-function messageProgress(message, now = /* @__PURE__ */ new Date(), timeoutMs = OVERLORD_HANDOFF_TIMEOUT_MS) {
+function messageProgress(message, now = /* @__PURE__ */ new Date(), timeoutMs = OVERLORD_HANDOFF_TIMEOUT_MS, ownerAlive) {
   if (message.state === "partial") return "partial";
   if (message.completedAt || message.state === "completed") return "completed";
   if (message.failedAt || message.state === "failed") return "failed";
   const startedAt = message.startedAt ?? message.deliveredAt;
   if (!startedAt) return "queued";
   const elapsed = now.getTime() - new Date(startedAt).getTime();
-  return Number.isFinite(elapsed) && elapsed >= timeoutMs ? "stalled" : "started";
+  if (!(Number.isFinite(elapsed) && elapsed >= timeoutMs)) return "started";
+  return ownerAlive === false ? "orphaned" : "stalled";
+}
+function messageElapsedMs(message, now = /* @__PURE__ */ new Date()) {
+  const startedAt = message.startedAt ?? message.deliveredAt;
+  if (!startedAt) return void 0;
+  const elapsed = now.getTime() - new Date(startedAt).getTime();
+  return Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : void 0;
+}
+function reconcileOverlordRun(run, ownerAlive, now = /* @__PURE__ */ new Date()) {
+  let changed = 0;
+  const messages = (run.messages ?? []).map((message) => {
+    if (messageProgress(message, now, OVERLORD_HANDOFF_TIMEOUT_MS, ownerAlive) === "orphaned") {
+      changed += 1;
+      return {
+        ...message,
+        state: "failed",
+        failedAt: now.toISOString(),
+        failureReason: message.failureReason ?? "orphaned: Overlord controller is not alive"
+      };
+    }
+    return message;
+  });
+  return changed > 0 ? { run: { ...run, messages }, changed } : { run, changed: 0 };
 }
 function servantProgress(run, servant, now = /* @__PURE__ */ new Date()) {
   const relevant = (run.messages ?? []).filter((message) => message.target === "all" || servant.slotId === message.target || normalizeServantTarget(servant.name) === message.target);
-  return relevant.some((message) => messageProgress(message, now) === "stalled") ? "stalled-after-delivery" : servant.state;
+  return relevant.some((message) => {
+    const progress = messageProgress(message, now);
+    return progress === "stalled" || progress === "orphaned";
+  }) ? "stalled-after-delivery" : servant.state;
 }
 function humanSafeText(text, maxLength = 160) {
   const redacted = (text ?? "").replace(/\bBearer\s+\S+/gi, "[redacted]").replace(/\b(api[_-]?key|token|secret)=\S+/gi, "$1=[redacted]").replace(/\b(sk|sakana|mmi)[-_][A-Za-z0-9_-]{10,}\b/g, "[redacted]").replace(/\s+/g, " ").trim();
@@ -11106,7 +11295,7 @@ function registerOverlordCommands(program3, deps = {}) {
       const plan2 = buildOverlordStartupPlan(args, root);
       const engine = `${options.engine ?? OVERLORD_DEFAULT_ENGINE}`;
       if (engine !== "fugu-api") throw new Error("--engine must be fugu-api");
-      if (!options.json) out("Starting Overlord.\nLoading run registry...\nChecking Fugu API...\n");
+      if (!options.json) out("Starting Overlord...\n");
       const preflightReport = await fuguApiPreflight();
       if (!preflightReport.ok) {
         err(`${renderOverlordPreflightFailure(preflightReport)}
@@ -11129,8 +11318,7 @@ function registerOverlordCommands(program3, deps = {}) {
         runToken: deps.runToken
       });
       writeOverlordRegistry(plan2.statePath, { activeRunId: run.runId, runs: { ...registry2.runs, [run.runId]: run } });
-      if (!options.json) out(`Summoning ${run.servants.length} Fugu servants...
-Preparing conversations...
+      if (!options.json) out(`Spawning ${run.servants.length} Fugu (1 ultra, ${run.servants.length - 1} normal)...
 `);
       run = markServantsStarting(run, isoNow(now));
       writeOverlordRegistry(plan2.statePath, { activeRunId: run.runId, runs: { ...registry2.runs, [run.runId]: run } });
@@ -11141,13 +11329,9 @@ Preparing conversations...
       else {
         const ready = run.servants.filter((servant) => servant.state === "ready").length;
         out(`${[
-          `Ready: ${ready}/${run.servants.length} servants ready.`,
+          `Ready: ${ready}/${run.servants.length}.`,
           `Mission: ${humanSafeText(run.task || "not provided yet")}`,
-          `Run: ${run.runId}`,
-          "Engine: Fugu API",
-          "",
-          "Overlord is idle and ready for your instruction.",
-          "Next: I will consult the servants and interview you, then propose a todo list for your approval."
+          `Run: ${run.runId}`
         ].join("\n")}
 `);
       }
@@ -11160,7 +11344,7 @@ Preparing conversations...
       process.exitCode = 1;
     }
   });
-  overlord.command("send").description("queue an assignment or redirect for active Overlord servant conversations").argument("<target>", "servant slot id/name, or all").argument("[message...]", "message to deliver to the servant session").option("--json", "print machine-readable output").action(async (target, message = [], options, command) => {
+  overlord.command("send").description("queue an assignment or redirect for active Overlord servant conversations").argument("<target>", "servant slot id/name, or all").argument("[message...]", "message to deliver to the servant session").option("--message-file <path>", "read the message from a UTF-8 file, or - for stdin (prefer a path; #1511)").option("--json", "print machine-readable output").action(async (target, message = [], options, command) => {
     const json = wantsJson(options, command);
     try {
       const statePath = defaultOverlordStatePath(cwd());
@@ -11169,8 +11353,9 @@ Preparing conversations...
       if (!run) throw new Error("no active Overlord run found");
       const normalized = normalizeServantTarget(target);
       if (!hasServantTarget(run, normalized)) throw new Error(`unknown Overlord servant target: ${target}`);
-      const text = message.join(" ").trim();
-      if (!text) throw new Error("message is required");
+      const text = resolveOverlordSendMessage(message, typeof options.messageFile === "string" ? options.messageFile : void 0);
+      if (!text) throw new Error("message is required (pass it inline or via --message-file)");
+      if (run.engine !== "fugu-api") throw new Error("active Overlord run does not use the fugu-api engine");
       const timestamp = isoNow(now);
       const queued = {
         id: deps.runId?.() ?? defaultMessageId(),
@@ -11180,23 +11365,19 @@ Preparing conversations...
         queuedAt: timestamp,
         state: "queued"
       };
-      if (run.engine !== "fugu-api") throw new Error("active Overlord run does not use the fugu-api engine");
       if (!json) out(`Sending assignment to ${normalized}...
 Awaiting Fugu responses...
 `);
-      const started = {
-        ...run,
+      const startedMessage = { ...queued, state: "started", startedAt: timestamp };
+      const started = persistRunMutation(statePath, run.runId, (fresh) => ({
+        ...fresh,
         updatedAt: timestamp,
-        messages: [...(run.messages ?? []).filter((m) => m.id !== queued.id), {
-          ...queued,
-          state: "started",
-          startedAt: timestamp
-        }]
-      };
-      writeOverlordRegistry(statePath, { ...registry2, runs: { ...registry2.runs, [run.runId]: started } });
+        messages: [...(fresh.messages ?? []).filter((m) => m.id !== queued.id), startedMessage]
+      }));
       const dispatched = await dispatchFuguApiMessage(started, queued, runFuguApi, now, fuguApiRetry);
-      writeOverlordRegistry(statePath, { ...registry2, runs: { ...registry2.runs, [run.runId]: dispatched } });
       const settled = (dispatched.messages ?? []).find((m) => m.id === queued.id);
+      const affected = computeAffectedSlots(dispatched.servants, normalized, settled);
+      persistRunMutation(statePath, run.runId, (fresh) => mergeConcurrentDispatch(fresh, dispatched, settled, affected, queued.id));
       const ok = settled?.state === "completed" || settled?.state === "partial";
       const payload = { ok, runId: run.runId, target: normalized, messageId: queued.id, state: settled?.state, responseText: settled?.responseText, failureReason: settled?.failureReason, servantResults: settled?.servantResults, statePath };
       if (json) out(`${JSON.stringify(payload, null, 2)}
@@ -11229,10 +11410,13 @@ State: ${payload2.statePath}
     }
     const summary = summarizeOverlordRun(run, { isPidAlive, now });
     const current = now();
+    const ownerAlive = summary.controller !== "lost";
+    const { run: reconciledRun, changed } = reconcileOverlordRun(run, ownerAlive, current);
+    if (changed > 0) persistRunMutation(statePath, run.runId, (fresh) => reconcileOverlordRun(fresh, ownerAlive, current).run);
     const payload = {
       ...summary,
       statePath,
-      task: run.task,
+      task: reconciledRun.task,
       engine: run.engine,
       ledgerPath: run.ledgerPath,
       sessions: run.servants.map((servant) => ({
@@ -11248,10 +11432,12 @@ State: ${payload2.statePath}
         lastEventAt: servant.lastEventAt,
         lastMessageCompletedAt: servant.lastMessageCompletedAt
       })),
-      messages: (run.messages ?? []).map((message) => ({
+      messages: (reconciledRun.messages ?? []).map((message) => ({
         id: message.id,
         target: message.target,
-        state: messageProgress(message, current),
+        state: messageProgress(message, current, OVERLORD_HANDOFF_TIMEOUT_MS, ownerAlive),
+        elapsedMs: messageElapsedMs(message, current),
+        boundMs: OVERLORD_HANDOFF_TIMEOUT_MS,
         queuedAt: message.queuedAt ?? message.createdAt,
         startedAt: message.startedAt ?? message.deliveredAt,
         completedAt: message.completedAt,
@@ -11264,7 +11450,7 @@ State: ${payload2.statePath}
     };
     if (json) out(`${JSON.stringify(payload, null, 2)}
 `);
-    else out(`${renderOverlordStatus(summary, run, current)}
+    else out(`${renderOverlordStatus(summary, reconciledRun, current)}
 State: ${statePath}
 `);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "2.57.0",
+  "version": "2.58.0",
   "description": "MMI Future CLI — delivers the org rules (whole-file), Jervaise-only continuity, and KB access. The cross-IDE engine the plugin's SessionStart hook drives.",
   "type": "module",
   "license": "UNLICENSED",