@xqli02/mneme 0.1.8 → 0.1.10

package/bin/mneme.mjs

@@ -60,6 +60,7 @@ const MNEME_COMMANDS = new Set([
   "up",
   "down",
   "ps",
+  "restart",
   "version",
   "--version",
   "-v",
@@ -142,6 +143,11 @@ switch (command) {
     await server(["status", ...args.slice(1)]);
     break;
   }
+  case "restart": {
+    const { server } = await import("../src/commands/server.mjs");
+    await server(["restart", ...args.slice(1)]);
+    break;
+  }
   case "version":
   case "--version":
   case "-v":
@@ -171,10 +177,10 @@ Usage:
   mneme compact                 Pre-compaction persistence check
 
   ${bold("Servers (dolt + opencode):")}
-  mneme up    [TARGET]          Start server(s)   (TARGET: dolt|opencode|all)
-  mneme down  [TARGET]          Stop server(s)
-  mneme ps    [TARGET]          Show server status
-  mneme server restart [TARGET] Restart server(s)
+  mneme up      [TARGET]        Start server(s)   (TARGET: dolt|opencode|all)
+  mneme down    [TARGET]        Stop server(s)
+  mneme ps      [TARGET]        Show server status
+  mneme restart [TARGET]        Restart server(s)
 
   ${bold("Task management (beads):")}
   mneme ready                   Show tasks with no blockers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xqli02/mneme",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Three-layer memory architecture for AI coding agents (Ledger + Beads + OpenCode)",
   "type": "module",
   "bin": {

package/src/commands/auto.mjs

@@ -2,7 +2,7 @@
  * mneme auto — Dual-agent autonomous supervisor loop.
  *
  * Uses two agents in the same opencode session:
- *   - Planner (default: gpt-5.2): analyzes goal, breaks down tasks, reviews results
+ *   - Planner (default: gpt-4.1): analyzes goal, breaks down tasks, reviews results
  *   - Executor (default: claude-opus-4.6): writes code, runs commands, implements changes
  *
  * The planner and executor alternate turns via per-message model switching.
@@ -35,7 +35,7 @@ import { color, log, run, has } from "../utils.mjs";
 
 // ── Default models ──────────────────────────────────────────────────────────
 
-const DEFAULT_PLANNER = "github-copilot/gpt-5.2";
+const DEFAULT_PLANNER = "github-copilot/gpt-4.1";
 const DEFAULT_EXECUTOR = "github-copilot/claude-opus-4.6";
 
 // ── Argument parsing ────────────────────────────────────────────────────────
@@ -382,11 +382,16 @@ function createInputQueue() {
 /**
  * Subscribe to SSE events and display agent output in real-time.
  * Returns an object with methods to control display and detect turn completion.
+ *
+ * Also tracks `lastOutputTime` so callers can detect stalls.
  */
 function createEventDisplay(client) {
   let running = false;
+  let connected = false;
   let turnResolve = null;
   let currentRole = null; // "planner" | "executor" — for display prefixing
+  let lastOutputTime = 0; // Date.now() of last SSE output
+  let hasReceivedAny = false; // true once any event arrives
 
   // Track incremental text and tool display state
   const printedTextLengths = new Map();
@@ -396,15 +401,26 @@ function createEventDisplay(client) {
     running = true;
     try {
       const iterator = await client.events.subscribe();
+      connected = true;
+      hasReceivedAny = false;
+      log.ok("SSE event stream connected");
       for await (const event of iterator) {
         if (!running) break;
+        if (!hasReceivedAny) hasReceivedAny = true;
         handleEvent(event);
       }
     } catch (err) {
+      connected = false;
       if (running) {
         console.error(
-          color.dim(`\n  [events] Stream ended: ${err.message}`),
+          color.dim(`\n  [events] Stream error: ${err.message}`),
         );
+        // Try to reconnect after a brief delay
+        await sleep(2000);
+        if (running) {
+          log.info("Reconnecting SSE...");
+          start().catch(() => {});
+        }
       }
     }
   }
@@ -425,12 +441,14 @@ function createEventDisplay(client) {
           if (newText) {
             process.stdout.write(newText);
             printedTextLengths.set(partId, part.text.length);
+            lastOutputTime = Date.now();
           }
         } else if (
           part.type === "tool-invocation" ||
           part.type === "tool-result"
         ) {
           displayToolPart(part, partId);
+          lastOutputTime = Date.now();
         }
         break;
       }
@@ -525,7 +543,15 @@ function createEventDisplay(client) {
     }
   }
 
-  return { start, stop, waitForTurnEnd, resetTurn };
+  return {
+    start,
+    stop,
+    waitForTurnEnd,
+    resetTurn,
+    get lastOutputTime() { return lastOutputTime; },
+    get connected() { return connected; },
+    get hasReceivedAny() { return hasReceivedAny; },
+  };
 }
 
 // ── Turn execution ──────────────────────────────────────────────────────────
@@ -533,6 +559,8 @@ function createEventDisplay(client) {
 /**
  * Send a message and wait for the turn to complete.
  * Handles /abort and /quit from input queue during execution.
+ * Prints heartbeat every 15s when no output is flowing.
+ * Warns at 30s of silence, auto-aborts at 120s of silence.
  *
  * @returns {{ status: string, aborted: boolean, quit: boolean }}
  */
@@ -556,15 +584,43 @@ async function executeTurn(
   // Send async — returns immediately
   await client.session.promptAsync(sessionId, body);
 
-  // Race: SSE turn completion vs user commands
+  // Quick check: if model is invalid, the session may error out almost
+  // instantly but promptAsync still returns 204. Poll once after a short
+  // delay to catch this before entering the long wait loop.
+  await sleep(2000);
+  try {
+    const sessions = await client.session.list();
+    const s = sessions?.find?.((ss) => ss.id === sessionId);
+    if (s && s.status && s.status !== "running" && s.status !== "pending") {
+      // Session already finished — likely an immediate error
+      const msgs = await client.session.messages(sessionId);
+      const lastMsg = msgs?.[msgs.length - 1];
+      const errInfo = lastMsg?.info?.error;
+      if (errInfo) {
+        const errMsg = errInfo.data?.message || errInfo.name || "unknown";
+        log.fail(`Model error: ${errMsg}`);
+        return { status: "error", aborted: true, quit: false };
+      }
+    }
+  } catch {
+    // Ignore probe failures — fall through to normal wait
+  }
+
+  const HEARTBEAT_INTERVAL = 15_000; // print elapsed every 15s of silence
+  const SILENCE_WARN = 30_000; // warn after 30s of no output
+  const SILENCE_ABORT = 120_000; // auto-abort after 120s of no output
+  const turnStartTime = Date.now();
+
+  // Race: SSE turn completion vs user commands vs silence timeout
   return new Promise((resolve) => {
     let resolved = false;
+    let warnedSilence = false;
 
     const done = (result) => {
       if (resolved) return;
       resolved = true;
       clearInterval(pollId);
-      clearTimeout(safetyId);
+      clearInterval(heartbeatId);
       resolve(result);
     };
 
@@ -573,6 +629,41 @@ async function executeTurn(
       done({ status, aborted: false, quit: false });
     });
 
+    // Heartbeat: show elapsed time when no output is flowing
+    const heartbeatId = setInterval(() => {
+      if (resolved) return;
+      const now = Date.now();
+      const elapsed = Math.round((now - turnStartTime) / 1000);
+      const lastOut = eventDisplay.lastOutputTime;
+      const silenceMs = lastOut > 0 ? now - lastOut : now - turnStartTime;
+
+      // Silence auto-abort
+      if (silenceMs >= SILENCE_ABORT) {
+        console.log(
+          color.dim(`\n  ⏱ ${elapsed}s elapsed — no output for ${Math.round(silenceMs / 1000)}s, auto-aborting`),
+        );
+        client.session.abort(sessionId).catch(() => {});
+        done({ status: "aborted", aborted: true, quit: false });
+        return;
+      }
+
+      // Silence warning
+      if (silenceMs >= SILENCE_WARN && !warnedSilence) {
+        warnedSilence = true;
+        console.log(
+          color.dim(`\n  ⏱ ${elapsed}s elapsed — no output for ${Math.round(silenceMs / 1000)}s (will abort at ${SILENCE_ABORT / 1000}s)`),
+        );
+        return;
+      }
+
+      // Regular heartbeat (only when silent for >HEARTBEAT_INTERVAL)
+      if (silenceMs >= HEARTBEAT_INTERVAL) {
+        process.stdout.write(
+          color.dim(`  [${elapsed}s] `),
+        );
+      }
+    }, HEARTBEAT_INTERVAL);
+
     // Poll input queue for /abort, /quit
     const pollId = setInterval(() => {
       if (!inputQueue.hasMessages()) return;
@@ -597,22 +688,6 @@ async function executeTurn(
         }
       }
     }, 200);
-
-    // Safety timeout: poll session status after 10 minutes
-    const safetyId = setTimeout(async () => {
-      if (resolved) return;
-      try {
-        // Try listing sessions and checking status
-        const sessions = await client.session.list();
-        const session = sessions?.find?.((s) => s.id === sessionId);
-        const s = session?.status;
-        if (s && s !== "running" && s !== "pending") {
-          done({ status: s, aborted: false, quit: false });
-        }
-      } catch {
-        // ignore
-      }
-    }, 600_000);
   });
 }
 
@@ -631,12 +706,49 @@ async function supervisorLoop(client, opts, inputQueue) {
   const plannerModel = parseModelSpec(opts.planner);
   const executorModel = parseModelSpec(opts.executor);
 
-  // Create session
+  // Create session first (needed for model probing)
   log.info("Creating session...");
   const session = await client.session.create({ title: "mneme auto" });
   const sessionId = session.id;
   log.ok(`Session: ${sessionId}`);
 
+  // ── Validate models by sending a real test prompt ──
+  // opencode models lists theoretical models, but the provider may reject them
+  // at runtime (e.g. Copilot plan doesn't include gpt-5.x). Only a real API
+  // call reveals this — sync prompt returns the error, async silently fails.
+  log.info("Validating models (API probe)...");
+  const probeModels = [
+    { label: "Planner", spec: opts.planner, parsed: plannerModel },
+    { label: "Executor", spec: opts.executor, parsed: executorModel },
+  ];
+  // Deduplicate if both use the same model
+  const seen = new Set();
+  for (const m of probeModels) {
+    if (seen.has(m.spec)) continue;
+    seen.add(m.spec);
+    try {
+      const result = await client.session.prompt(sessionId, {
+        parts: [{ type: "text", text: "Say OK" }],
+        model: m.parsed,
+      });
+      // Check if the response contains an error
+      const err = result?.info?.error;
+      if (err) {
+        const msg = err.data?.message || err.name || "unknown error";
+        log.fail(`${m.label} model "${m.spec}" rejected by provider: ${msg}`);
+        console.log(color.dim("  Tip: run 'opencode models' to see listed models, but not all may be available on your plan."));
+        throw new Error(`${m.label} model unavailable: ${msg}`);
+      }
+      log.ok(`${m.label} model verified: ${m.spec}`);
+    } catch (probeErr) {
+      if (probeErr.message.includes("unavailable") || probeErr.message.includes("rejected")) {
+        throw probeErr; // re-throw our own errors
+      }
+      // API call itself failed — might be a transient issue
+      log.warn(`${m.label} model probe inconclusive: ${probeErr.message}`);
+    }
+  }
+
   // Start SSE event display
   const eventDisplay = createEventDisplay(client);
   eventDisplay.start().catch(() => {});
@@ -720,6 +832,7 @@ async function supervisorLoop(client, opts, inputQueue) {
         `\n${color.bold(`── Cycle ${cycle} · Planner`)} ${color.dim(`(${opts.planner})`)} ${color.bold("────────────────────")}`,
       );
 
+      log.info(`Sending prompt to Planner (${opts.planner})...`);
       eventDisplay.resetTurn("planner");
       const plannerResult = await executeTurn(
         client,
@@ -775,6 +888,7 @@ async function supervisorLoop(client, opts, inputQueue) {
       );
 
       const executorPrompt = buildExecutorPrompt();
+      log.info(`Sending prompt to Executor (${opts.executor})...`);
       eventDisplay.resetTurn("executor");
       const executorResult = await executeTurn(
         client,