@xqli02/mneme 0.1.11 → 0.1.12

package/src/commands/auto.mjs

@@ -1,36 +1,41 @@
 /**
  * mneme auto — Dual-agent autonomous supervisor loop.
  *
+ * Architecture (default: daemon + TUI):
+ *   1. Start opencode serve (if not already running)
+ *   2. Fork self as background daemon (prompt driver)
+ *   3. exec opencode attach (foreground TUI)
+ *
+ * The daemon drives prompts in the background while the user views
+ * everything through opencode's TUI. User can type directly in TUI
+ * to intervene — the daemon detects this via SSE and pauses.
+ *
+ * Use --headless for the original CLI mode (no TUI, streaming to stdout).
+ *
  * Uses two agents in the same opencode session:
  *   - 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.
- * Both see the full conversation history within the same session.
- *
- * Flow per cycle:
- *   1. Planner: receives goal/context → outputs structured instructions
- *   2. Executor: receives planner's instructions → implements changes
- *   3. Planner: reviews executor's output → more instructions or "DONE"
- *   4. Repeat until planner says done or user intervenes
- *
  * Usage:
- *   mneme auto                              # Auto-pick from ready beads
+ *   mneme auto                              # Daemon + TUI mode (default)
  *   mneme auto "Build auth module"          # Start with a specific goal
+ *   mneme auto --headless                   # CLI mode (no TUI)
  *   mneme auto --attach http://localhost:4096
  *   mneme auto --port 4096
- *   mneme auto --planner github-copilot/gpt-5.2  --executor github-copilot/claude-opus-4.6
+ *   mneme auto --planner github-copilot/gpt-4.1  --executor github-copilot/claude-opus-4.6
  */
 
-import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { readFileSync, existsSync, readdirSync, writeFileSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
+import { fork, execSync } from "node:child_process";
 import {
   startOpencodeServer,
   attachOpencodeServer,
   parseModelSpec,
-  stopOpencodeServer,
+  findOpencodeProcess,
 } from "../opencode-server.mjs";
+import { createClient } from "../opencode-client.mjs";
 import { color, log, run, has } from "../utils.mjs";
 
 // ── Default models ──────────────────────────────────────────────────────────
@@ -38,6 +43,10 @@ import { color, log, run, has } from "../utils.mjs";
 const DEFAULT_PLANNER = "github-copilot/gpt-4.1";
 const DEFAULT_EXECUTOR = "github-copilot/claude-opus-4.6";
 
+// ── Log file path ───────────────────────────────────────────────────────────
+
+const LOG_FILE = ".mneme-auto.log";
+
 // ── Argument parsing ────────────────────────────────────────────────────────
 
 function parseArgs(argv) {
@@ -48,6 +57,10 @@ function parseArgs(argv) {
     maxCycles: 50, // planner-executor cycles
     planner: DEFAULT_PLANNER,
     executor: DEFAULT_EXECUTOR,
+    headless: false, // --headless: use original CLI mode
+    _daemon: false, // --_daemon: internal flag for forked daemon process
+    _daemonUrl: null, // --_daemon-url: server URL passed to daemon
+    _daemonSessionId: null, // --_daemon-session: session ID passed to daemon
   };
   const positional = [];
 
@@ -71,6 +84,18 @@ function parseArgs(argv) {
       opts.executor = argv[++i];
     } else if (arg.startsWith("--executor=")) {
       opts.executor = arg.split("=").slice(1).join("=");
+    } else if (arg === "--headless") {
+      opts.headless = true;
+    } else if (arg === "--_daemon") {
+      opts._daemon = true;
+    } else if (arg === "--_daemon-url" && argv[i + 1]) {
+      opts._daemonUrl = argv[++i];
+    } else if (arg.startsWith("--_daemon-url=")) {
+      opts._daemonUrl = arg.split("=").slice(1).join("=");
+    } else if (arg === "--_daemon-session" && argv[i + 1]) {
+      opts._daemonSessionId = argv[++i];
+    } else if (arg.startsWith("--_daemon-session=")) {
+      opts._daemonSessionId = arg.split("=").slice(1).join("=");
     } else if (arg === "--help" || arg === "-h") {
       showHelp();
       process.exit(0);
@@ -91,8 +116,9 @@ function showHelp() {
 ${color.bold("mneme auto")} — Dual-agent autonomous supervisor
 
 Usage:
-  mneme auto                         Auto-pick from ready beads
+  mneme auto                         Daemon + TUI mode (default)
   mneme auto "Build auth module"     Start with a specific goal
+  mneme auto --headless              CLI mode (no TUI, streams to stdout)
   mneme auto --attach URL            Attach to existing server
   mneme auto --port PORT             Use specific port (default: 4097)
 
@@ -100,11 +126,24 @@ Options:
   --planner MODEL    Planner model (default: ${DEFAULT_PLANNER})
   --executor MODEL   Executor model (default: ${DEFAULT_EXECUTOR})
   --max-cycles N     Max planner-executor cycles (default: 50)
+  --headless         Use CLI mode instead of TUI
   --attach URL       Attach to running opencode server
   --port PORT        Port for auto-started server
 
-Commands while running:
+Behavior when no goal is provided:
+  Asks whether to pick from existing beads or discuss a plan with the
+  Planner first. In TUI mode, the Planner presents current tasks and
+  suggestions — discuss interactively, then type /go to start execution.
+
+Default mode (daemon + TUI):
+  Opens the opencode TUI. The auto-driver runs in the background,
+  alternating planner/executor prompts. Type directly in the TUI
+  to intervene — the daemon pauses while you interact.
+
+Headless mode (--headless):
+  Streams agent output to stdout. Commands while running:
   Type any message   Inject feedback (sent to planner next turn)
+  /go                Finish goal discussion and start execution
   /status            Show bead status
   /skip              Skip current bead
   /abort             Abort current turn
@@ -112,6 +151,29 @@ Commands while running:
 `);
 }
 
+// ── File logger (for daemon mode) ───────────────────────────────────────────
+
+/**
+ * Create a file-based logger for daemon mode.
+ * Replaces all console output. Truncates the log file on start.
+ */
+function createFileLogger(logPath) {
+  // Truncate on start
+  writeFileSync(logPath, `[mneme auto daemon] Started at ${new Date().toISOString()}\n`);
+
+  function write(level, msg) {
+    const ts = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    appendFileSync(logPath, `[${ts}] [${level}] ${msg}\n`);
+  }
+
+  return {
+    info: (msg) => write("INFO", msg),
+    ok: (msg) => write("OK", msg),
+    warn: (msg) => write("WARN", msg),
+    fail: (msg) => write("FAIL", msg),
+  };
+}
+
 // ── Bead management ─────────────────────────────────────────────────────────
 
 function getReadyBeads() {
@@ -280,6 +342,66 @@ Be specific and actionable.`;
   return prompt;
 }
 
+/**
+ * Build the planner's discovery prompt — for interactive goal discussion
+ * when no goal was provided on the command line.
+ */
+function buildPlannerDiscoveryPrompt() {
+  // Gather current project state for context
+  const readyBeads = run("bd ready") || "";
+  const openBeads = run("bd list --status=open") || "";
+  const inProgressBeads = run("bd list --status=in_progress") || "";
+
+  let beadContext = "";
+  if (inProgressBeads && !inProgressBeads.includes("No ")) {
+    beadContext += `### In-progress tasks:\n\`\`\`\n${inProgressBeads}\n\`\`\`\n\n`;
+  }
+  if (readyBeads && !readyBeads.includes("No ready")) {
+    beadContext += `### Ready tasks (unblocked):\n\`\`\`\n${readyBeads}\n\`\`\`\n\n`;
+  }
+  if (openBeads && !openBeads.includes("No ")) {
+    beadContext += `### Open tasks:\n\`\`\`\n${openBeads}\n\`\`\`\n\n`;
+  }
+
+  return `## Role: Planner (Goal Discovery)
+
+You are the PLANNER in discovery mode. No goal was provided, so your job is to help the user decide what to work on.
+
+${beadContext ? `## Current Task State\n\n${beadContext}` : "## No existing tasks found.\n\n"}## Instructions
+
+1. Review the project state above (existing tasks, facts, codebase)
+2. Suggest 2-3 concrete goals the user could work on, prioritized by impact
+3. For each suggestion, explain WHY it's a good next step
+4. Ask the user which direction they'd like to go, or if they have something else in mind
+
+Keep your suggestions specific and actionable. The user will discuss with you and then type **\`/go\`** when they're ready to start execution.
+
+**Important**: This is a conversation. Respond to the user's input naturally. When they type \`/go\`, the system will finalize the goal and begin the planner-executor loop.`;
+}
+
+/**
+ * Build a prompt to finalize the goal after /go is received.
+ * The planner should summarize the agreed goal and produce the first
+ * executor instruction.
+ */
+function buildPlannerFinalizeGoalPrompt() {
+  return `## Role: Planner (Finalize Goal)
+
+The user has typed \`/go\`, signaling they're ready to start execution.
+
+Based on our discussion above, do the following:
+
+1. Summarize the agreed goal in 1-2 sentences
+2. Check existing beads with \`mneme ready\` and \`mneme list --status=open\`
+3. If this maps to an existing bead, claim it: \`mneme update <id> --status=in_progress\`
+4. If not, create a new bead: \`mneme create --title="..." --description="..." --type=task -p 2\`
+5. Break the goal into specific, actionable steps
+6. Give the Executor clear instructions for what to implement FIRST
+7. When all work is complete (in future turns), include "TASK_DONE" in your response
+
+Output your plan and the first instruction for the Executor.`;
+}
+
 /**
  * Build the executor's prompt (wrapping the planner's output).
  */
@@ -297,10 +419,11 @@ Rules:
 - Report what you did when finished so the Planner can review`;
 }
 
-// ── User input handling ─────────────────────────────────────────────────────
+// ── User input handling (headless mode only) ────────────────────────────────
 
 /**
  * Non-blocking stdin reader with message queue.
+ * Only used in --headless mode.
  */
 function createInputQueue() {
   const queue = [];
@@ -320,22 +443,22 @@ function createInputQueue() {
       if (!trimmed) return;
 
       if (trimmed === "/quit" || trimmed === "/exit" || trimmed === "/stop") {
-        console.log(color.dim("  → quitting after current turn..."));
+        console.log(color.dim("  -> quitting after current turn..."));
         queue.push({ type: "quit" });
       } else if (trimmed === "/status") {
         queue.push({ type: "status" });
       } else if (trimmed === "/skip") {
         console.log(
-          color.dim("  → will skip current bead after this cycle"),
+          color.dim("  -> will skip current bead after this cycle"),
         );
         queue.push({ type: "skip" });
       } else if (trimmed === "/abort") {
-        console.log(color.dim("  → aborting current turn..."));
+        console.log(color.dim("  -> aborting current turn..."));
         queue.push({ type: "abort" });
       } else {
         queue.push({ type: "message", text: trimmed });
         console.log(
-          color.dim("  → queued, will send to planner next cycle"),
+          color.dim("  -> queued, will send to planner next cycle"),
         );
       }
     });
@@ -377,26 +500,26 @@ function createInputQueue() {
   };
 }
 
-// ── Event display (streaming) ───────────────────────────────────────────────
+// ── Event display (streaming, headless mode) ────────────────────────────────
 
 /**
  * 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.
+ * Only used in --headless mode.
  */
 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
+  let currentRole = null;
+  let lastOutputTime = 0;
+  let hasReceivedAny = false;
 
-  // Track incremental text and tool display state
   const printedTextLengths = new Map();
   const displayedToolStates = new Map();
-  const deltaParts = new Set(); // parts that received delta events
+  const deltaParts = new Set();
 
   async function start() {
     running = true;
@@ -416,7 +539,6 @@ function createEventDisplay(client) {
         console.error(
           color.dim(`\n  [events] Stream error: ${err.message}`),
         );
-        // Try to reconnect after a brief delay
         await sleep(2000);
         if (running) {
           log.info("Reconnecting SSE...");
@@ -431,7 +553,6 @@ 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);
@@ -442,7 +563,6 @@ function createEventDisplay(client) {
         break;
       }
 
-      // ── Part snapshots (full text at end, tool states) ──
       case "message.part.updated": {
         if (!props.part) break;
         const part = props.part;
@@ -455,12 +575,9 @@ function createEventDisplay(client) {
           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();
           }
@@ -469,7 +586,6 @@ function createEventDisplay(client) {
         break;
       }
 
-      // ── Session status (busy → idle/completed) ──
       case "session.status": {
         const status = props.status?.type || props.status;
         if (status && status !== "busy" && status !== "pending") {
@@ -481,7 +597,6 @@ function createEventDisplay(client) {
         break;
       }
 
-      // ── Session updated (metadata; also check for status) ──
       case "session.updated": {
         const info = props.info || props.session || {};
         const status = info.status?.type || info.status;
@@ -494,12 +609,9 @@ 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;
@@ -519,7 +631,7 @@ function createEventDisplay(client) {
     if (state === "call" && lastState !== "call") {
       const argsStr = summarizeArgs(inv.args);
       console.log(
-        `\n${color.bold(`  ⚡ ${toolName}`)}${argsStr ? color.dim(` ${argsStr}`) : ""}`,
+        `\n${color.bold(`  * ${toolName}`)}${argsStr ? color.dim(` ${argsStr}`) : ""}`,
       );
       displayedToolStates.set(partId, "call");
     } else if (state === "result" && lastState !== "result") {
@@ -560,10 +672,6 @@ function createEventDisplay(client) {
     return str.length > 120 ? str.slice(0, 120) + "..." : str;
   }
 
-  /**
-   * Wait for the current turn to complete via SSE.
-   * Returns a promise that resolves with the session status.
-   */
   function waitForTurnEnd() {
     return new Promise((resolve) => {
       turnResolve = resolve;
@@ -596,17 +704,167 @@ function createEventDisplay(client) {
   };
 }
 
-// ── Turn execution ──────────────────────────────────────────────────────────
+// ── Daemon event monitor (silent, for daemon mode) ──────────────────────────
+
+/**
+ * SSE listener for daemon mode — tracks turn completion and detects
+ * user-initiated messages, but produces NO stdout output.
+ * All logging goes to file.
+ */
+function createDaemonEventMonitor(client, dlog) {
+  let running = false;
+  let connected = false;
+  let turnResolve = null;
+  let lastOutputTime = 0;
+  let hasReceivedAny = false;
+
+  // Track known prompt texts we sent — to distinguish user messages
+  const knownPromptTexts = new Set();
+
+  // Callback for user message detection
+  let onUserMessage = null;
+
+  async function start() {
+    running = true;
+    try {
+      const iterator = await client.events.subscribe();
+      connected = true;
+      hasReceivedAny = false;
+      dlog.ok("SSE event stream connected (daemon)");
+      for await (const event of iterator) {
+        if (!running) break;
+        if (!hasReceivedAny) hasReceivedAny = true;
+        handleEvent(event);
+      }
+    } catch (err) {
+      connected = false;
+      if (running) {
+        dlog.warn(`SSE stream error: ${err.message}`);
+        await sleep(2000);
+        if (running) {
+          dlog.info("Reconnecting SSE...");
+          start().catch(() => {});
+        }
+      }
+    }
+  }
+
+  function handleEvent(event) {
+    const type = event.type || "";
+    const props = event.properties || {};
+
+    switch (type) {
+      case "message.part.delta": {
+        // Just track that output is happening
+        if (props.field === "text" && props.delta) {
+          lastOutputTime = Date.now();
+        }
+        break;
+      }
+
+      case "message.part.updated": {
+        if (props.part) {
+          lastOutputTime = Date.now();
+        }
+        break;
+      }
+
+      case "session.status": {
+        const status = props.status?.type || props.status;
+        if (status && status !== "busy" && status !== "pending") {
+          if (turnResolve) {
+            turnResolve(status);
+            turnResolve = null;
+          }
+        }
+        break;
+      }
+
+      case "session.updated": {
+        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;
+          }
+        }
+        break;
+      }
+
+      case "message.updated": {
+        const info = props.info || {};
+        // Detect user-initiated messages: role === "user" with text we didn't send
+        const role = info.role;
+        if (role === "user" && info.parts) {
+          const text = info.parts
+            .filter((p) => p.type === "text")
+            .map((p) => p.text || "")
+            .join("\n")
+            .trim();
+          if (text && !knownPromptTexts.has(text)) {
+            dlog.info(`User message detected: "${text.slice(0, 80)}..."`);
+            if (onUserMessage) onUserMessage(text);
+          }
+        }
+        if (info.finish && info.finish !== "pending") {
+          lastOutputTime = Date.now();
+        }
+        break;
+      }
+
+      default:
+        break;
+    }
+  }
+
+  function waitForTurnEnd() {
+    return new Promise((resolve) => {
+      turnResolve = resolve;
+    });
+  }
+
+  function resetTurn() {
+    // Nothing visual to reset in daemon mode
+  }
+
+  function registerPrompt(text) {
+    // Register a prompt text so we can distinguish our prompts from user's
+    knownPromptTexts.add(text.trim());
+  }
+
+  function stop() {
+    running = false;
+    if (turnResolve) {
+      turnResolve("stopped");
+      turnResolve = null;
+    }
+  }
+
+  return {
+    start,
+    stop,
+    waitForTurnEnd,
+    resetTurn,
+    registerPrompt,
+    set onUserMessage(fn) { onUserMessage = fn; },
+    get onUserMessage() { return onUserMessage; },
+    get lastOutputTime() { return lastOutputTime; },
+    get connected() { return connected; },
+    get hasReceivedAny() { return hasReceivedAny; },
+  };
+}
+
+// ── Turn execution (headless mode) ──────────────────────────────────────────
 
 /**
- * Send a message and wait for the turn to complete.
+ * Send a message and wait for the turn to complete (headless mode).
  * 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 }}
  */
-async function executeTurn(
+async function executeTurnHeadless(
   client,
   sessionId,
   prompt,
@@ -623,18 +881,14 @@ async function executeTurn(
     body.model = modelSpec;
   }
 
-  // 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.
+  // Quick check for immediate model errors
   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;
@@ -645,15 +899,14 @@ async function executeTurn(
       }
     }
   } catch {
-    // Ignore probe failures — fall through to normal wait
+    // Ignore probe failures
   }
 
-  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 HEARTBEAT_INTERVAL = 15_000;
+  const SILENCE_WARN = 30_000;
+  const SILENCE_ABORT = 120_000;
   const turnStartTime = Date.now();
 
-  // Race: SSE turn completion vs user commands vs silence timeout
   return new Promise((resolve) => {
     let resolved = false;
     let warnedSilence = false;
@@ -666,12 +919,10 @@ async function executeTurn(
       resolve(result);
     };
 
-    // SSE completion
     eventDisplay.waitForTurnEnd().then((status) => {
       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();
@@ -679,26 +930,23 @@ async function executeTurn(
       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`),
+          color.dim(`\n  [${elapsed}s] 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)`),
+          color.dim(`\n  [${elapsed}s] 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] `),
@@ -706,7 +954,6 @@ async function executeTurn(
       }
     }, HEARTBEAT_INTERVAL);
 
-    // Poll input queue for /abort, /quit
     const pollId = setInterval(() => {
       if (!inputQueue.hasMessages()) return;
       const items = inputQueue.drain();
@@ -725,7 +972,6 @@ async function executeTurn(
           showBeadStatus();
         }
         if (item.type === "message" || item.type === "skip") {
-          // Re-queue for processing between cycles
           inputQueue.pushBack(item);
         }
       }
@@ -733,8 +979,91 @@ async function executeTurn(
   });
 }
 
+// ── Turn execution (daemon mode) ────────────────────────────────────────────
+
+/**
+ * Send a message and wait for the turn to complete (daemon mode).
+ * No stdout output — all logging to file. No input queue.
+ *
+ * @returns {{ status: string, aborted: boolean }}
+ */
+async function executeTurnDaemon(
+  client,
+  sessionId,
+  prompt,
+  modelSpec,
+  monitor,
+  dlog,
+) {
+  monitor.resetTurn();
+  monitor.registerPrompt(prompt);
+
+  const body = {
+    parts: [{ type: "text", text: prompt }],
+  };
+  if (modelSpec) {
+    body.model = modelSpec;
+  }
+
+  await client.session.promptAsync(sessionId, body);
+
+  // Quick check for immediate model errors
+  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") {
+      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";
+        dlog.fail(`Model error: ${errMsg}`);
+        return { status: "error", aborted: true };
+      }
+    }
+  } catch {
+    // Ignore probe failures
+  }
+
+  const SILENCE_ABORT = 120_000;
+  const turnStartTime = Date.now();
+
+  return new Promise((resolve) => {
+    let resolved = false;
+
+    const done = (result) => {
+      if (resolved) return;
+      resolved = true;
+      clearInterval(silenceCheckId);
+      resolve(result);
+    };
+
+    monitor.waitForTurnEnd().then((status) => {
+      done({ status, aborted: false });
+    });
+
+    // Check for silence timeouts
+    const silenceCheckId = setInterval(() => {
+      if (resolved) return;
+      const now = Date.now();
+      const elapsed = Math.round((now - turnStartTime) / 1000);
+      const lastOut = monitor.lastOutputTime;
+      const silenceMs = lastOut > 0 ? now - lastOut : now - turnStartTime;
+
+      if (silenceMs >= SILENCE_ABORT) {
+        dlog.warn(`${elapsed}s elapsed, no output for ${Math.round(silenceMs / 1000)}s — auto-aborting`);
+        client.session.abort(sessionId).catch(() => {});
+        done({ status: "aborted", aborted: true });
+      }
+    }, 15_000);
+  });
+}
+
+// ── Status display (headless only) ─────────────────────────────────────────
+
 function showBeadStatus() {
-  console.log(`\n${color.bold("── Status ──")}`);
+  console.log(`\n${color.bold("-- Status --")}`);
   const ready = run("bd ready") || "  (none)";
   const inProgress = run("bd list --status=in_progress") || "  (none)";
   console.log(`  ${color.bold("Ready:")} ${ready}`);
@@ -742,60 +1071,26 @@ function showBeadStatus() {
   console.log("");
 }
 
-// ── Supervisor loop ─────────────────────────────────────────────────────────
+// ── Supervisor loop (headless mode — original CLI) ──────────────────────────
 
-async function supervisorLoop(client, opts, inputQueue) {
+async function supervisorLoopHeadless(client, opts, inputQueue) {
   const plannerModel = parseModelSpec(opts.planner);
   const executorModel = parseModelSpec(opts.executor);
 
-  // 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.
+  // Validate models
   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}`);
-    }
-  }
+  await validateModels(client, sessionId, opts, log);
 
   // Start SSE event display
   const eventDisplay = createEventDisplay(client);
   eventDisplay.start().catch(() => {});
 
-  // Inject system context (noReply)
+  // Inject system context
   const systemContext = buildSystemContext(opts);
   try {
     await client.session.prompt(sessionId, {
@@ -808,10 +1103,50 @@ async function supervisorLoop(client, opts, inputQueue) {
   }
 
   let cycle = 0;
+  let startMode = "beads"; // default: pick from beads
+
+  // If no explicit goal, ask user whether to pick from beads or discuss a plan.
+  if (!opts.goal) {
+    const choice = await askStartModeHeadless(inputQueue);
+    if (choice === "quit") {
+      eventDisplay.stop();
+      return;
+    }
+    startMode = choice; // "beads" or "discuss"
+  }
+
+  // If user chose to discuss, enter goal discussion before main loop.
+  if (startMode === "discuss") {
+    const goResult = await goalDiscussionHeadless(
+      client, sessionId, plannerModel, eventDisplay, inputQueue,
+    );
+    if (!goResult) {
+      log.info("User quit during goal discussion.");
+      eventDisplay.stop();
+      return;
+    }
+    // Goal discussion complete — planner finalize prompt has produced
+    // the first executor instruction. Jump straight to executor turn.
+    cycle++;
+    console.log(
+      `\n${color.bold(`-- Cycle ${cycle} / Executor`)} ${color.dim(`(${opts.executor})`)} ${color.bold("-------------------")}`,
+    );
+    const executorPrompt = buildExecutorPrompt();
+    log.info(`Sending prompt to Executor (${opts.executor})...`);
+    eventDisplay.resetTurn("executor");
+    const executorResult = await executeTurnHeadless(
+      client, sessionId, executorPrompt, executorModel,
+      eventDisplay, inputQueue,
+    );
+    console.log("");
+    if (executorResult.quit) { log.info("User requested quit."); eventDisplay.stop(); return; }
+    if (executorResult.aborted) { log.info("Executor turn aborted."); }
+    await sleep(1000);
+    // Fall through to the main loop (cycle is now 1, will get planner review)
+  }
 
   try {
     while (cycle < opts.maxCycles) {
-      // ── Process queued user commands between cycles ──
       let userFeedback = null;
       let shouldSkip = false;
 
@@ -822,40 +1157,30 @@ async function supervisorLoop(client, opts, inputQueue) {
             log.info("User requested quit.");
             return;
           }
-          if (item.type === "skip") {
-            shouldSkip = true;
-          }
-          if (item.type === "status") {
-            showBeadStatus();
-          }
-          if (item.type === "message") {
-            userFeedback = item.text;
-          }
+          if (item.type === "skip") shouldSkip = true;
+          if (item.type === "status") showBeadStatus();
+          if (item.type === "message") userFeedback = item.text;
         }
       }
 
       if (shouldSkip) {
         log.info("Skipping current bead...");
-        // Fall through to pick next bead
       }
 
-      // ── Pick a task (first cycle or after skip) ──
       let plannerPrompt = null;
 
       if (cycle === 0) {
-        // First cycle: use goal or pick a bead
         if (opts.goal) {
           plannerPrompt = buildPlannerGoalPrompt(opts.goal);
         } else {
-          plannerPrompt = pickBeadForPlanner();
+          // No explicit goal, but beads exist — pick from beads
+          plannerPrompt = pickBeadForPlanner(log);
         }
       } else {
-        // Subsequent cycles: planner reviews executor's work
         plannerPrompt = buildPlannerReviewPrompt(userFeedback);
       }
 
       if (!plannerPrompt) {
-        // No work available
         const open = getOpenBeads();
         if (open.length === 0) {
           log.ok("All beads completed! Nothing left to do.");
@@ -869,97 +1194,262 @@ async function supervisorLoop(client, opts, inputQueue) {
 
       cycle++;
 
-      // ── Planner turn ──
+      // Planner turn
       console.log(
-        `\n${color.bold(`── Cycle ${cycle} · Planner`)} ${color.dim(`(${opts.planner})`)} ${color.bold("────────────────────")}`,
+        `\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,
-        sessionId,
-        plannerPrompt,
-        plannerModel,
-        eventDisplay,
-        inputQueue,
+      const plannerResult = await executeTurnHeadless(
+        client, sessionId, plannerPrompt, plannerModel,
+        eventDisplay, inputQueue,
       );
-      console.log(""); // newline after output
+      console.log("");
 
-      if (plannerResult.quit) {
-        log.info("User requested quit.");
-        return;
-      }
-      if (plannerResult.aborted) {
-        log.info("Planner turn aborted.");
-        continue;
-      }
+      if (plannerResult.quit) { log.info("User requested quit."); return; }
+      if (plannerResult.aborted) { log.info("Planner turn aborted."); continue; }
 
-      // Check if planner said TASK_DONE — we need to read the last message
-      // from the session to see the planner's output
+      // Check TASK_DONE
       let plannerSaidDone = false;
       try {
         const messages = await client.session.messages(sessionId);
         if (messages && messages.length > 0) {
           const lastMsg = messages[messages.length - 1];
           const text = extractMessageText(lastMsg);
-          if (text.includes("TASK_DONE")) {
-            plannerSaidDone = true;
-          }
+          if (text.includes("TASK_DONE")) plannerSaidDone = true;
         }
-      } catch {
-        // Can't check, proceed with executor turn
-      }
+      } catch { /* proceed */ }
 
       if (plannerSaidDone) {
         log.ok("Planner declared task complete.");
-        // Pick next bead on next cycle
-        cycle = 0; // reset cycle counter for next task
-        const nextBead = pickBeadForPlanner();
-        if (!nextBead) {
-          log.ok("No more tasks. Finished.");
-          break;
-        }
-        // plannerPrompt for next iteration will be set at top of loop
+        cycle = 0;
+        const nextBead = pickBeadForPlanner(log);
+        if (!nextBead) { log.ok("No more tasks. Finished."); break; }
         continue;
       }
 
-      // ── Executor turn ──
+      // Executor turn
       console.log(
-        `\n${color.bold(`── Cycle ${cycle} · Executor`)} ${color.dim(`(${opts.executor})`)} ${color.bold("───────────────────")}`,
+        `\n${color.bold(`-- Cycle ${cycle} / Executor`)} ${color.dim(`(${opts.executor})`)} ${color.bold("-------------------")}`,
       );
 
       const executorPrompt = buildExecutorPrompt();
       log.info(`Sending prompt to Executor (${opts.executor})...`);
       eventDisplay.resetTurn("executor");
-      const executorResult = await executeTurn(
-        client,
-        sessionId,
-        executorPrompt,
-        executorModel,
-        eventDisplay,
-        inputQueue,
+      const executorResult = await executeTurnHeadless(
+        client, sessionId, executorPrompt, executorModel,
+        eventDisplay, inputQueue,
       );
-      console.log(""); // newline after output
+      console.log("");
 
-      if (executorResult.quit) {
-        log.info("User requested quit.");
-        return;
+      if (executorResult.quit) { log.info("User requested quit."); return; }
+      if (executorResult.aborted) { log.info("Executor turn aborted."); }
+
+      await sleep(1000);
+    }
+
+    if (cycle >= opts.maxCycles) {
+      log.warn(`Reached max cycles (${opts.maxCycles}). Stopping.`);
+    }
+  } finally {
+    eventDisplay.stop();
+  }
+}
+
+// ── Supervisor loop (daemon mode) ───────────────────────────────────────────
+
+async function supervisorLoopDaemon(client, sessionId, opts, dlog) {
+  const plannerModel = parseModelSpec(opts.planner);
+  const executorModel = parseModelSpec(opts.executor);
+
+  // Start SSE event monitor (silent)
+  const monitor = createDaemonEventMonitor(client, dlog);
+
+  // Track whether user is interacting via TUI
+  let userInteracting = false;
+  let userTurnResolve = null;
+
+  monitor.onUserMessage = (text) => {
+    dlog.info(`User typed in TUI, pausing auto loop...`);
+    userInteracting = true;
+    // The user message triggers a model response. We need to wait for
+    // that response to complete before resuming our auto loop.
+    // The next session.status=idle will signal completion.
+  };
+
+  monitor.start().catch(() => {});
+
+  // Inject system context
+  const systemContext = buildSystemContext(opts);
+  monitor.registerPrompt(systemContext);
+  try {
+    await client.session.prompt(sessionId, {
+      noReply: true,
+      parts: [{ type: "text", text: systemContext }],
+    });
+    dlog.ok("Context injected");
+  } catch (err) {
+    dlog.warn(`Context injection: ${err.message}`);
+  }
+
+  let cycle = 0;
+
+  // If no explicit goal, enter goal discussion with planner.
+  // The discovery prompt lists existing beads (if any) and suggestions.
+  // User discusses in TUI, types /go when ready. If they want to pick
+  // from beads, the planner will incorporate that into its plan.
+  if (!opts.goal) {
+    dlog.info("No goal specified — entering goal discussion with Planner.");
+    const goResult = await goalDiscussionDaemon(
+      client, sessionId, plannerModel, monitor, dlog,
+    );
+    if (!goResult) {
+      dlog.info("Goal discussion ended without /go. Exiting.");
+      monitor.stop();
+      return;
+    }
+    // Goal discussion complete — planner finalize prompt has produced
+    // the first executor instruction. Jump straight to executor turn.
+    cycle++;
+    dlog.info(`Cycle ${cycle} / Executor (${opts.executor}) [post-goal-discussion]`);
+    const executorPrompt = buildExecutorPrompt();
+    const executorResult = await executeTurnDaemon(
+      client, sessionId, executorPrompt, executorModel, monitor, dlog,
+    );
+    if (executorResult.aborted) {
+      dlog.warn("Executor turn aborted.");
+    }
+    await sleep(1000);
+    // Fall through to the main loop (cycle is now 1, will get planner review)
+  }
+
+  try {
+    while (cycle < opts.maxCycles) {
+      // If user is interacting, wait for the model to finish responding
+      // to their message before we send the next auto prompt
+      if (userInteracting) {
+        dlog.info("Waiting for user's turn to complete...");
+        await monitor.waitForTurnEnd();
+        userInteracting = false;
+        dlog.info("User turn complete, resuming auto loop.");
+        // After user intervention, planner should review
+        // (fall through to planner review prompt)
+      }
+
+      let plannerPrompt = null;
+
+      if (cycle === 0) {
+        if (opts.goal) {
+          plannerPrompt = buildPlannerGoalPrompt(opts.goal);
+        } else {
+          // No explicit goal, but beads exist — pick from beads
+          plannerPrompt = pickBeadForPlanner(dlog);
+        }
+      } else {
+        plannerPrompt = buildPlannerReviewPrompt(null);
       }
+
+      if (!plannerPrompt) {
+        const open = getOpenBeads();
+        if (open.length === 0) {
+          dlog.ok("All beads completed! Nothing left to do.");
+          break;
+        }
+        dlog.warn("All beads blocked. Waiting 30s before retry...");
+        await sleep(30_000);
+        continue;
+      }
+
+      cycle++;
+
+      // Planner turn
+      dlog.info(`Cycle ${cycle} / Planner (${opts.planner})`);
+      const plannerResult = await executeTurnDaemon(
+        client, sessionId, plannerPrompt, plannerModel, monitor, dlog,
+      );
+
+      if (plannerResult.aborted) {
+        dlog.warn("Planner turn aborted.");
+        continue;
+      }
+
+      // Check TASK_DONE
+      let plannerSaidDone = false;
+      try {
+        const messages = await client.session.messages(sessionId);
+        if (messages && messages.length > 0) {
+          const lastMsg = messages[messages.length - 1];
+          const text = extractMessageText(lastMsg);
+          if (text.includes("TASK_DONE")) plannerSaidDone = true;
+        }
+      } catch { /* proceed */ }
+
+      if (plannerSaidDone) {
+        dlog.ok("Planner declared task complete.");
+        cycle = 0;
+        const nextBead = pickBeadForPlanner(dlog);
+        if (!nextBead) { dlog.ok("No more tasks. Finished."); break; }
+        continue;
+      }
+
+      // Executor turn
+      dlog.info(`Cycle ${cycle} / Executor (${opts.executor})`);
+      const executorPrompt = buildExecutorPrompt();
+      const executorResult = await executeTurnDaemon(
+        client, sessionId, executorPrompt, executorModel, monitor, dlog,
+      );
+
       if (executorResult.aborted) {
-        log.info("Executor turn aborted.");
-        // Planner will review on next cycle
+        dlog.warn("Executor turn aborted.");
       }
 
-      // Small pause between cycles
       await sleep(1000);
     }
 
     if (cycle >= opts.maxCycles) {
-      log.warn(`Reached max cycles (${opts.maxCycles}). Stopping.`);
+      dlog.warn(`Reached max cycles (${opts.maxCycles}). Stopping.`);
     }
   } finally {
-    eventDisplay.stop();
+    monitor.stop();
+  }
+}
+
+// ── Shared helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Validate models by sending a real test prompt.
+ * Works with both console logger (log) and file logger (dlog).
+ */
+async function validateModels(client, sessionId, opts, logger) {
+  const plannerModel = parseModelSpec(opts.planner);
+  const executorModel = parseModelSpec(opts.executor);
+  const probeModels = [
+    { label: "Planner", spec: opts.planner, parsed: plannerModel },
+    { label: "Executor", spec: opts.executor, parsed: executorModel },
+  ];
+  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,
+      });
+      const err = result?.info?.error;
+      if (err) {
+        const msg = err.data?.message || err.name || "unknown error";
+        logger.fail(`${m.label} model "${m.spec}" rejected by provider: ${msg}`);
+        throw new Error(`${m.label} model unavailable: ${msg}`);
+      }
+      logger.ok(`${m.label} model verified: ${m.spec}`);
+    } catch (probeErr) {
+      if (probeErr.message.includes("unavailable") || probeErr.message.includes("rejected")) {
+        throw probeErr;
+      }
+      logger.warn(`${m.label} model probe inconclusive: ${probeErr.message}`);
+    }
   }
 }
 
@@ -967,27 +1457,24 @@ async function supervisorLoop(client, opts, inputQueue) {
  * Try to pick a bead and return a planner prompt for it.
  * Returns null if no beads available.
  */
-function pickBeadForPlanner() {
-  // Check in-progress first
+function pickBeadForPlanner(logger) {
   const inProgress = getInProgressBeads();
   if (inProgress.length > 0) {
     const beadId = extractBeadId(inProgress[0]);
     if (beadId) {
-      log.info(`Resuming: ${beadId}`);
+      logger.info(`Resuming: ${beadId}`);
       return buildPlannerBeadPrompt(beadId);
     }
   }
 
-  // Check ready beads
   const ready = getReadyBeads();
   if (ready.length === 0) return null;
 
   const beadId = extractBeadId(ready[0]);
   if (!beadId) return null;
 
-  // Claim it
   run(`bd update ${beadId} --status=in_progress`);
-  log.info(`Picked: ${beadId}`);
+  logger.info(`Picked: ${beadId}`);
   return buildPlannerBeadPrompt(beadId);
 }
 
@@ -1022,6 +1509,231 @@ async function waitForInput(inputQueue) {
   }
 }
 
+/**
+ * Ask the user whether to pick from beads or discuss a plan (headless mode).
+ * Shows current beads state and waits for the user to choose.
+ *
+ * @returns {"beads"|"discuss"|"quit"}
+ */
+async function askStartModeHeadless(inputQueue) {
+  const inProgress = getInProgressBeads();
+  const ready = getReadyBeads();
+  const hasBeads = inProgress.length > 0 || ready.length > 0;
+
+  console.log(`\n${color.bold("-- What would you like to do?")} ${color.bold("--")}`);
+  if (hasBeads) {
+    if (inProgress.length > 0) {
+      console.log(color.dim(`  In-progress beads: ${inProgress.length}`));
+    }
+    if (ready.length > 0) {
+      console.log(color.dim(`  Ready beads: ${ready.length}`));
+    }
+  } else {
+    console.log(color.dim("  No beads available."));
+  }
+  console.log("");
+  if (hasBeads) {
+    console.log(`  ${color.bold("1")}  Pick from beads (auto-select a task)`);
+  }
+  console.log(`  ${color.bold("2")}  Discuss with Planner (plan before execution)`);
+  console.log(color.dim("\n  Type 1 or 2, or /quit to exit.\n"));
+
+  while (true) {
+    await waitForInput(inputQueue);
+    const items = inputQueue.drain();
+    for (const item of items) {
+      if (item.type === "quit") return "quit";
+      if (item.type === "message") {
+        const t = item.text.trim();
+        if (t === "1" && hasBeads) return "beads";
+        if (t === "2") return "discuss";
+        console.log(color.dim(`  Please type ${hasBeads ? "1 or 2" : "2"}, or /quit to exit.`));
+      }
+    }
+  }
+}
+
+// ── Goal discussion (headless mode) ─────────────────────────────────────────
+
+/**
+ * Interactive goal discussion in headless mode.
+ * Planner suggests goals, user discusses, user types /go to proceed.
+ *
+ * @returns {boolean} true if /go was received and discussion completed,
+ *                    false if user quit.
+ */
+async function goalDiscussionHeadless(client, sessionId, plannerModel, eventDisplay, inputQueue) {
+  console.log(
+    `\n${color.bold("-- Goal Discussion")} ${color.dim("(type /go when ready to start execution)")} ${color.bold("--")}`,
+  );
+  console.log(color.dim("  Discuss with the Planner what to work on. Type /go to begin.\n"));
+
+  // Send discovery prompt to planner
+  const discoveryPrompt = buildPlannerDiscoveryPrompt();
+  log.info("Sending discovery prompt to Planner...");
+  eventDisplay.resetTurn("planner");
+  const discoveryResult = await executeTurnHeadless(
+    client, sessionId, discoveryPrompt, plannerModel,
+    eventDisplay, inputQueue,
+  );
+  console.log("");
+
+  if (discoveryResult.quit) return false;
+  if (discoveryResult.aborted) {
+    log.warn("Discovery prompt aborted. Retrying...");
+  }
+
+  // Discussion loop: user talks to planner until /go
+  while (true) {
+    // Wait for user input
+    console.log(color.dim("\n  [waiting for your input... type /go to start, /quit to exit]\n"));
+    await waitForInput(inputQueue);
+
+    const items = inputQueue.drain();
+    let userText = null;
+    let goReceived = false;
+    let quitReceived = false;
+
+    for (const item of items) {
+      if (item.type === "quit") {
+        quitReceived = true;
+        break;
+      }
+      if (item.type === "message") {
+        // Check if the user typed /go
+        if (item.text.toLowerCase().trim() === "/go") {
+          goReceived = true;
+          break;
+        }
+        userText = item.text;
+      }
+      if (item.type === "abort") {
+        // Ignore /abort during discussion
+      }
+      if (item.type === "status") {
+        showBeadStatus();
+      }
+      if (item.type === "skip") {
+        // Ignore /skip during discussion
+      }
+    }
+
+    if (quitReceived) return false;
+
+    if (goReceived) {
+      // Send finalize prompt to planner
+      console.log(
+        `\n${color.bold("-- Finalizing Goal")} ${color.bold("--------------------")}`,
+      );
+      log.info("Sending finalize prompt to Planner...");
+      eventDisplay.resetTurn("planner");
+      const finalizeResult = await executeTurnHeadless(
+        client, sessionId, buildPlannerFinalizeGoalPrompt(), plannerModel,
+        eventDisplay, inputQueue,
+      );
+      console.log("");
+
+      if (finalizeResult.quit) return false;
+      return true;
+    }
+
+    if (userText) {
+      // Send user's message to planner for continued discussion
+      const discussPrompt = `## Role: Planner (Goal Discussion)
+
+The user says:
+
+> ${userText}
+
+Continue the goal discussion. Help the user refine what to work on.
+When they're ready, remind them to type \`/go\` to begin execution.`;
+
+      eventDisplay.resetTurn("planner");
+      const discussResult = await executeTurnHeadless(
+        client, sessionId, discussPrompt, plannerModel,
+        eventDisplay, inputQueue,
+      );
+      console.log("");
+
+      if (discussResult.quit) return false;
+    }
+  }
+}
+
+// ── Goal discussion (daemon mode) ───────────────────────────────────────────
+
+/**
+ * Goal discussion in daemon+TUI mode.
+ * Sends a discovery prompt to planner, then waits for the user to
+ * type /go in the TUI. While waiting, the user can freely discuss
+ * with the planner via the TUI — the daemon stays paused.
+ *
+ * @returns {boolean} true if /go was received, false if daemon should exit.
+ */
+async function goalDiscussionDaemon(client, sessionId, plannerModel, monitor, dlog) {
+  dlog.info("Starting goal discussion (no goal provided)");
+
+  // Send discovery prompt
+  const discoveryPrompt = buildPlannerDiscoveryPrompt();
+  dlog.info("Sending discovery prompt to Planner...");
+  const discoveryResult = await executeTurnDaemon(
+    client, sessionId, discoveryPrompt, plannerModel, monitor, dlog,
+  );
+
+  if (discoveryResult.aborted) {
+    dlog.warn("Discovery prompt aborted");
+  }
+
+  // Now wait for user to type /go in the TUI.
+  // The monitor detects user messages via SSE. We listen for /go specifically.
+  dlog.info("Waiting for user to type /go in TUI...");
+
+  return new Promise((resolve) => {
+    let resolved = false;
+
+    // Save previous onUserMessage handler
+    const prevHandler = monitor.onUserMessage;
+
+    monitor.onUserMessage = (text) => {
+      if (resolved) return;
+      const trimmed = text.trim().toLowerCase();
+
+      if (trimmed === "/go") {
+        dlog.info("User typed /go — finalizing goal");
+        resolved = true;
+
+        // Restore previous handler
+        monitor.onUserMessage = prevHandler || null;
+
+        // Send finalize prompt
+        (async () => {
+          const finalizePrompt = buildPlannerFinalizeGoalPrompt();
+          monitor.registerPrompt(finalizePrompt);
+          dlog.info("Sending finalize prompt to Planner...");
+          const finalizeResult = await executeTurnDaemon(
+            client, sessionId, finalizePrompt, plannerModel, monitor, dlog,
+          );
+          if (finalizeResult.aborted) {
+            dlog.warn("Finalize prompt aborted");
+          }
+          resolve(true);
+        })();
+        return;
+      }
+
+      // Any other user message: the user is discussing with the planner via
+      // TUI. The TUI + opencode handle this automatically (user types →
+      // model responds). The daemon just needs to wait for those turns to
+      // complete before checking for /go again.
+      dlog.info(`User discussing in TUI: "${text.slice(0, 60)}..."`);
+      // Wait for the model's response to finish
+      monitor.waitForTurnEnd().then(() => {
+        dlog.info("Planner response to user complete, still waiting for /go");
+      });
+    };
+  });
+}
+
 // ── Main entry point ────────────────────────────────────────────────────────
 
 export async function auto(argv) {
@@ -1034,42 +1746,131 @@ export async function auto(argv) {
     process.exit(1);
   }
 
+  // ── Path 1: Internal daemon process (forked by main process) ──
+  if (opts._daemon) {
+    return runDaemonProcess(opts);
+  }
+
+  // ── Path 2: Headless mode (original CLI) ──
+  if (opts.headless) {
+    return runHeadlessMode(opts);
+  }
+
+  // ── Path 3: Default — daemon + TUI ──
+  return runDaemonTuiMode(opts);
+}
+
+// ── Path 1: Daemon process ──────────────────────────────────────────────────
+
+async function runDaemonProcess(opts) {
+  const dlog = createFileLogger(LOG_FILE);
+  dlog.info(`Daemon starting — goal: ${opts.goal || "(auto-pick)"}`);
+  dlog.info(`Planner: ${opts.planner}, Executor: ${opts.executor}`);
+
+  const url = opts._daemonUrl;
+  if (!url) {
+    dlog.fail("No server URL provided (--_daemon-url)");
+    process.exit(1);
+  }
+
+  // Connect to the opencode serve instance
+  const client = createClient(url);
+  try {
+    const health = await client.health();
+    if (!health?.healthy) throw new Error("not healthy");
+    dlog.ok(`Connected to server at ${url}`);
+  } catch (err) {
+    dlog.fail(`Cannot connect to server at ${url}: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Create or reuse session
+  let sessionId = opts._daemonSessionId;
+  if (!sessionId) {
+    dlog.info("Creating session...");
+    const session = await client.session.create({ title: "mneme auto" });
+    sessionId = session.id;
+    dlog.ok(`Session: ${sessionId}`);
+
+    // Validate models in new session
+    dlog.info("Validating models (API probe)...");
+    try {
+      await validateModels(client, sessionId, opts, dlog);
+    } catch (err) {
+      dlog.fail(`Model validation failed: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    dlog.ok(`Reusing session: ${sessionId}`);
+  }
+
+  // Handle signals for clean shutdown
+  let shuttingDown = false;
+  const shutdown = (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    dlog.info(`Received ${signal}, shutting down daemon...`);
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
+
+  // Monitor parent process (the TUI). When it exits, we should too.
+  // In Node.js, when the parent exits, the daemon gets SIGHUP if not
+  // fully detached. We also poll as a fallback.
+  if (process.ppid) {
+    const parentPid = process.ppid;
+    const parentCheckId = setInterval(() => {
+      try {
+        // Signal 0 checks if process exists
+        process.kill(parentPid, 0);
+      } catch {
+        dlog.info("Parent process exited, daemon shutting down.");
+        clearInterval(parentCheckId);
+        process.exit(0);
+      }
+    }, 5000);
+    parentCheckId.unref?.();
+  }
+
+  // Run the daemon supervisor loop
+  try {
+    await supervisorLoopDaemon(client, sessionId, opts, dlog);
+  } catch (err) {
+    dlog.fail(`Daemon supervisor error: ${err.message}`);
+  }
+
+  dlog.ok("Daemon finished.");
+  process.exit(0);
+}
+
+// ── Path 2: Headless mode (original CLI) ────────────────────────────────────
+
+async function runHeadlessMode(opts) {
   console.log(
-    `\n${color.bold("mneme auto")} — dual-agent autonomous supervisor\n`,
-  );
-  console.log(
-    `  ${color.bold("Planner:")}  ${opts.planner}`,
-  );
-  console.log(
-    `  ${color.bold("Executor:")} ${opts.executor}\n`,
+    `\n${color.bold("mneme auto")} — dual-agent autonomous supervisor (headless)\n`,
   );
+  console.log(`  ${color.bold("Planner:")}  ${opts.planner}`);
+  console.log(`  ${color.bold("Executor:")} ${opts.executor}\n`);
   console.log(color.dim("Commands while running:"));
-  console.log(
-    color.dim("  Type any message  → inject feedback to planner"),
-  );
-  console.log(color.dim("  /status           → show bead status"));
-  console.log(color.dim("  /skip             → skip current bead"));
-  console.log(color.dim("  /abort            → abort current turn"));
-  console.log(color.dim("  /quit             → stop and exit\n"));
+  console.log(color.dim("  Type any message  -> inject feedback to planner"));
+  console.log(color.dim("  /status           -> show bead status"));
+  console.log(color.dim("  /skip             -> skip current bead"));
+  console.log(color.dim("  /abort            -> abort current turn"));
+  console.log(color.dim("  /quit             -> stop and exit\n"));
 
-  // Start or attach to server
   let serverCtx;
   try {
     if (opts.attach) {
       serverCtx = await attachOpencodeServer(opts.attach);
-      log.ok(
-        `Attached to ${serverCtx.url} (v${serverCtx.version})`,
-      );
+      log.ok(`Attached to ${serverCtx.url} (v${serverCtx.version})`);
     } else {
       serverCtx = await startOpencodeServer({ port: opts.port });
       if (serverCtx.alreadyRunning) {
-        log.ok(
-          `Server already running at ${serverCtx.url} (v${serverCtx.version})`,
-        );
+        log.ok(`Server already running at ${serverCtx.url} (v${serverCtx.version})`);
       } else {
-        log.ok(
-          `Server started at ${serverCtx.url} (v${serverCtx.version})`,
-        );
+        log.ok(`Server started at ${serverCtx.url} (v${serverCtx.version})`);
       }
     }
   } catch (err) {
@@ -1077,18 +1878,15 @@ export async function auto(argv) {
     process.exit(1);
   }
 
-  // Start input queue
   const inputQueue = createInputQueue();
   inputQueue.start();
 
-  // Run supervisor
   try {
-    await supervisorLoop(serverCtx.client, opts, inputQueue);
+    await supervisorLoopHeadless(serverCtx.client, opts, inputQueue);
   } catch (err) {
     log.fail(`Supervisor error: ${err.message}`);
   } finally {
     inputQueue.stop();
-    // Only kill server if WE started it
     if (serverCtx.serverProcess) {
       log.info("Shutting down server...");
       serverCtx.serverProcess.kill("SIGTERM");
@@ -1097,6 +1895,141 @@ export async function auto(argv) {
   }
 }
 
+// ── Path 3: Daemon + TUI mode (default) ────────────────────────────────────
+
+async function runDaemonTuiMode(opts) {
+  console.log(
+    `\n${color.bold("mneme auto")} — dual-agent autonomous supervisor\n`,
+  );
+  console.log(`  ${color.bold("Planner:")}  ${opts.planner}`);
+  console.log(`  ${color.bold("Executor:")} ${opts.executor}`);
+  console.log(`  ${color.bold("Mode:")}     daemon + TUI\n`);
+
+  // Step 1: Start opencode serve (if not running)
+  let serverUrl;
+  let weStartedServer = false;
+
+  if (opts.attach) {
+    // User provided a URL
+    serverUrl = opts.attach;
+    log.info(`Using provided server: ${serverUrl}`);
+    try {
+      const client = createClient(serverUrl);
+      const health = await client.health();
+      if (!health?.healthy) throw new Error("not healthy");
+      log.ok(`Server healthy (v${health.version})`);
+    } catch (err) {
+      log.fail(`Cannot connect to ${serverUrl}: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    serverUrl = `http://127.0.0.1:${opts.port}`;
+    // Check if already running
+    try {
+      const client = createClient(serverUrl);
+      const health = await client.health();
+      if (health?.healthy) {
+        log.ok(`Server already running at ${serverUrl} (v${health.version})`);
+      } else {
+        throw new Error("not healthy");
+      }
+    } catch {
+      // Need to start it
+      log.info(`Starting opencode serve on port ${opts.port}...`);
+      try {
+        const ctx = await startOpencodeServer({ port: opts.port, detached: true });
+        weStartedServer = !ctx.alreadyRunning;
+        log.ok(`Server started at ${ctx.url} (v${ctx.version})`);
+      } catch (err) {
+        log.fail(`Failed to start server: ${err.message}`);
+        process.exit(1);
+      }
+    }
+  }
+
+  // Step 2: Create session and validate models before forking daemon
+  log.info("Creating session and validating models...");
+  const client = createClient(serverUrl);
+  let sessionId;
+  try {
+    const session = await client.session.create({ title: "mneme auto" });
+    sessionId = session.id;
+    log.ok(`Session: ${sessionId}`);
+    await validateModels(client, sessionId, opts, log);
+  } catch (err) {
+    log.fail(`Setup failed: ${err.message}`);
+    if (weStartedServer) {
+      log.info("Stopping server we started...");
+      run(`kill $(ps aux | grep 'opencode.*serve.*--port.*${opts.port}' | grep -v grep | awk '{print $2}') 2>/dev/null`);
+    }
+    process.exit(1);
+  }
+
+  // Step 3: Fork daemon process
+  log.info("Forking daemon process...");
+
+  // Build daemon argv
+  const daemonArgs = [
+    "auto",
+    "--_daemon",
+    "--_daemon-url", serverUrl,
+    "--_daemon-session", sessionId,
+    "--planner", opts.planner,
+    "--executor", opts.executor,
+    "--max-cycles", String(opts.maxCycles),
+  ];
+  if (opts.goal) {
+    daemonArgs.push(opts.goal);
+  }
+
+  // Fork using the mneme CLI entry point
+  const mnemeEntry = join(
+    new URL(".", import.meta.url).pathname,
+    "..", "..", "bin", "mneme.mjs",
+  );
+
+  const daemon = fork(mnemeEntry, daemonArgs, {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore", "ipc"],
+  });
+
+  daemon.unref();
+  // Disconnect IPC so parent can exit cleanly
+  daemon.disconnect();
+
+  log.ok(`Daemon forked (PID: ${daemon.pid})`);
+  log.info(`Log file: ${LOG_FILE}`);
+
+  // Small delay to let daemon connect before we launch TUI
+  await sleep(1000);
+
+  // Step 4: exec opencode attach (replaces this process)
+  log.info(`Launching TUI: opencode attach ${serverUrl}`);
+  console.log(color.dim("  Type directly in the TUI to intervene. The daemon pauses automatically.\n"));
+
+  try {
+    execSync(`opencode attach ${serverUrl}`, {
+      stdio: "inherit",
+      // This blocks until the TUI exits
+    });
+  } catch {
+    // TUI exited (normal or error)
+  }
+
+  // TUI exited — kill daemon
+  log.info("TUI exited.");
+  try {
+    process.kill(daemon.pid, "SIGTERM");
+    log.info(`Sent SIGTERM to daemon (PID: ${daemon.pid})`);
+  } catch {
+    // Daemon may have already exited
+  }
+
+  // If we started the server and --attach wasn't used, optionally stop it
+  // (leave it running — user can `mneme down` manually)
+  log.ok("mneme auto finished.");
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function sleep(ms) {