@xqli02/mneme 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xqli02/mneme",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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 ────────────────────────────────────────────────────────
@@ -396,6 +396,7 @@ function createEventDisplay(client) {
   // Track incremental text and tool display state
   const printedTextLengths = new Map();
   const displayedToolStates = new Map();
+  const deltaParts = new Set(); // parts that received delta events
 
   async function start() {
     running = true;
@@ -430,32 +431,61 @@ function createEventDisplay(client) {
     const props = event.properties || {};
 
     switch (type) {
+      // ── Incremental text deltas (streaming) ──
+      case "message.part.delta": {
+        const partId = props.partID || props.partId;
+        if (partId) deltaParts.add(partId);
+        if (props.field === "text" && props.delta) {
+          process.stdout.write(props.delta);
+          lastOutputTime = Date.now();
+        }
+        break;
+      }
+
+      // ── Part snapshots (full text at end, tool states) ──
       case "message.part.updated": {
         if (!props.part) break;
         const part = props.part;
         const partId = part.id || `${props.messageID}-${props.index}`;
 
-        if (part.type === "text" && part.text) {
-          const prev = printedTextLengths.get(partId) || 0;
-          const newText = part.text.slice(prev);
-          if (newText) {
-            process.stdout.write(newText);
-            printedTextLengths.set(partId, part.text.length);
-            lastOutputTime = Date.now();
-          }
-        } else if (
+        if (
           part.type === "tool-invocation" ||
           part.type === "tool-result"
         ) {
           displayToolPart(part, partId);
           lastOutputTime = Date.now();
         }
+        // For text parts: we rely on message.part.delta for streaming,
+        // so only use updated as a fallback if we missed the deltas
+        if (part.type === "text" && part.text) {
+          const prev = printedTextLengths.get(partId) || 0;
+          if (prev === 0 && !deltaParts.has(partId)) {
+            // We never saw deltas for this part — print the full text
+            process.stdout.write(part.text);
+            lastOutputTime = Date.now();
+          }
+          printedTextLengths.set(partId, part.text.length);
+        }
+        break;
+      }
+
+      // ── Session status (busy → idle/completed) ──
+      case "session.status": {
+        const status = props.status?.type || props.status;
+        if (status && status !== "busy" && status !== "pending") {
+          if (turnResolve) {
+            turnResolve(status);
+            turnResolve = null;
+          }
+        }
         break;
       }
 
+      // ── Session updated (metadata; also check for status) ──
       case "session.updated": {
-        const status = props.session?.status || props.status;
-        if (status && status !== "running" && status !== "pending") {
+        const info = props.info || props.session || {};
+        const status = info.status?.type || info.status;
+        if (status && status !== "busy" && status !== "running" && status !== "pending") {
           if (turnResolve) {
             turnResolve(status);
             turnResolve = null;
@@ -464,6 +494,17 @@ function createEventDisplay(client) {
         break;
       }
 
+      // ── Message-level finish detection ──
+      case "message.updated": {
+        const info = props.info || {};
+        if (info.finish && info.finish !== "pending") {
+          // Model finished generating — mark as turn end candidate
+          // (session.status should follow, but use this as backup)
+          lastOutputTime = Date.now();
+        }
+        break;
+      }
+
       default:
         break;
     }
@@ -533,6 +574,7 @@ function createEventDisplay(client) {
     currentRole = role;
     printedTextLengths.clear();
     displayedToolStates.clear();
+    deltaParts.clear();
   }
 
   function stop() {
@@ -584,6 +626,28 @@ async function executeTurn(
   // Send async — returns immediately
   await client.session.promptAsync(sessionId, body);
 
+  // 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
@@ -684,30 +748,49 @@ async function supervisorLoop(client, opts, inputQueue) {
   const plannerModel = parseModelSpec(opts.planner);
   const executorModel = parseModelSpec(opts.executor);
 
-  // ── Validate models ──
-  log.info("Validating models...");
-  const modelsOutput = run("opencode models 2>/dev/null") || "";
-  const validateModel = (label, spec) => {
-    // Look for the model ID in the output; opencode models lists "provider/model"
-    if (modelsOutput && !modelsOutput.includes(spec)) {
-      log.fail(`${label} model "${spec}" not found in available models.`);
-      console.log(color.dim("  Available models:"));
-      for (const line of modelsOutput.split("\n").filter(l => l.trim())) {
-        console.log(color.dim(`    ${line.trim()}`));
-      }
-      throw new Error(`Invalid ${label.toLowerCase()} model: ${spec}`);
-    }
-  };
-  validateModel("Planner", opts.planner);
-  validateModel("Executor", opts.executor);
-  log.ok("Models validated");
-
-  // 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(() => {});

package/src/opencode-client.mjs

@@ -65,7 +65,17 @@ export function createClient(baseUrl) {
         } else if (line.startsWith("data:")) {
           const data = line.slice(5).trim();
           try {
-            currentEvent.properties = JSON.parse(data);
+            const parsed = JSON.parse(data);
+            // opencode sends all fields in data JSON: {type, properties, ...}
+            // Merge into currentEvent, but prefer explicit event: line if present
+            if (parsed && typeof parsed === "object") {
+              if (!currentEvent.type && parsed.type) {
+                currentEvent.type = parsed.type;
+              }
+              currentEvent.properties = parsed.properties || parsed;
+            } else {
+              currentEvent.properties = parsed;
+            }
           } catch {
             currentEvent.properties = data;
           }