groove-dev 0.27.196 → 0.27.198

package/packages/daemon/src/innerchat.js

@@ -2,6 +2,7 @@
 
 import { randomUUID } from 'crypto';
 import { deliverInstruction } from './deliver.js';
+import { RelayClient, parsePeerRef } from './innerchat-relay.js';
 
 // An unanswered ask holds an HTTP request open and blocks the calling agent,
 // so it has to be bounded.
@@ -16,6 +17,12 @@ const MAX_EXCHANGES = 12;
 const CONTEXT_TURNS = 4;
 const MAX_TURN_CHARS = 1200;
 
+// Sender-side outbox polling for async (tell) replies from a peer. Bounded: we
+// poll a peer only after we've sent it a tell, and stop after a run of empty
+// polls — a heads-down agent gets a generous window to finish, then we let go.
+const OUTBOX_POLL_MS = 3000;
+const OUTBOX_IDLE_STOP = 10; // ~30s of silence ends the poll
+
 /**
  * Agent-to-agent consultation.
  *
@@ -29,13 +36,40 @@ const MAX_TURN_CHARS = 1200;
  * a question reaches its target whether it's mid-task, idle, or stopped.
  */
 export class InnerChat {
-  constructor(daemon) {
+  constructor(daemon, opts = {}) {
     this.daemon = daemon;
     this.threads = new Map();
     // agentId being asked -> pending record (resolve/reject/timer/threadId)
     this.awaiting = new Map();
     // asker id -> id of the agent it is currently blocked on
     this.blockedOn = new Map();
+
+    // Cross-daemon relay (spec: plans/cross-daemon-innerchat-spec.md).
+    this.relay = opts.relay || new RelayClient();
+    // Replies to async (tell) relays, queued here on the answering daemon until
+    // the sending daemon polls its outbox. Entry: { id, forDaemonId, toName,
+    // fromName, fromDaemonId, text, threadId, ts }.
+    this.relayOutbox = [];
+    // alias -> { timer, idle, busy } for active sender-side outbox pollers.
+    this._outboxPollers = new Map();
+  }
+
+  // Configured peers: [{ alias, url, daemonId }]. Empty by default — cross-daemon
+  // routing is off until the user adds a peer on both machines.
+  _peers() {
+    return Array.isArray(this.daemon.config?.innerchatPeers) ? this.daemon.config.innerchatPeers : [];
+  }
+
+  _peerByAlias(alias) {
+    return this._peers().find((p) => p.alias === alias) || null;
+  }
+
+  _peerByDaemonId(daemonId) {
+    return this._peers().find((p) => p.daemonId === daemonId) || null;
+  }
+
+  _daemonId() {
+    return this.daemon.federation.getDaemonId();
   }
 
   /**
@@ -252,6 +286,9 @@ export class InnerChat {
     if (pending.mode === 'async') {
       this._clearAwait(agentId);
       this._forwardAsyncReply(pending, answerTurn, text);
+    } else if (pending.mode === 'relay-async') {
+      this._clearAwait(agentId);
+      this._enqueueOutbox(pending, answerTurn, text);
     } else {
       pending.resolve(text);
     }
@@ -392,6 +429,228 @@ export class InnerChat {
     return pending ? this.threads.get(pending.threadId) : null;
   }
 
+  // ── Cross-daemon relay ──────────────────────────────────────
+  //
+  // A `name@alias` target routes here. The sending side (askRemote/tellRemote)
+  // signs the request with this daemon's federation key and POSTs it to the
+  // peer; the answering side (receiveRelay) verifies the signer, resolves the
+  // name in its OWN registry, and delivers through the normal InnerChat pipe
+  // with a guest identity so caps, threads, and audit all work unchanged.
+
+  // True when `to` names a peer. Lets the route layer branch cheaply.
+  isRemoteRef(to) {
+    const parsed = parsePeerRef(to);
+    return !!(parsed && parsed.alias);
+  }
+
+  // Ask an agent on a peer daemon and BLOCK for its reply (relayed over the
+  // still-open HTTP response — one-way transport suffices for ask/reply).
+  async askRemote(fromAgent, toName, alias, message, opts = {}) {
+    const peer = this._requirePeer(alias);
+    const envelope = this._signRelay('ask', fromAgent, toName, message);
+    const { ok, status, json } = await this._sendRelay(peer, envelope, opts.timeoutMs);
+    if (!ok) throw new Error(json?.error || `Peer "${alias}" refused the relay (HTTP ${status})`);
+    this.daemon.audit.log('innerchat.relay.ask', { peer: alias, from: fromAgent.name, to: toName });
+    return { reply: json.reply, remote: true, peer: alias, threadId: json.threadId };
+  }
+
+  // Send to an agent on a peer daemon WITHOUT blocking. The reply, if any, is
+  // queued in the peer's outbox and picked up by our poller, then delivered
+  // back to the local sender — keeping the one-way topology sufficient.
+  async tellRemote(fromAgent, toName, alias, message) {
+    const peer = this._requirePeer(alias);
+    const envelope = this._signRelay('tell', fromAgent, toName, message);
+    const { ok, status, json } = await this._sendRelay(peer, envelope);
+    if (!ok) throw new Error(json?.error || `Peer "${alias}" refused the relay (HTTP ${status})`);
+    this.daemon.audit.log('innerchat.relay.tell', { peer: alias, from: fromAgent.name, to: toName });
+    this._ensureOutboxPoll(peer);
+    return { delivered: true, remote: true, peer: alias, threadId: json.threadId };
+  }
+
+  _requirePeer(alias) {
+    const peer = this._peerByAlias(alias);
+    if (!peer) {
+      const aliases = this._peers().map((p) => p.alias);
+      throw new Error(
+        `No configured InnerChat peer "${alias}".`
+        + (aliases.length ? ` Known peers: ${aliases.join(', ')}.` : ' No peers are configured.'),
+      );
+    }
+    return peer;
+  }
+
+  _signRelay(kind, fromAgent, toName, message) {
+    const signed = this.daemon.federation.sign({
+      v: 1,
+      type: 'innerchat.relay',
+      kind,
+      fromName: fromAgent.name,
+      fromRole: fromAgent.role,
+      fromDaemonId: this._daemonId(),
+      toName,
+      message,
+    });
+    return { payload: signed.payload, signature: signed.signature };
+  }
+
+  _sendRelay(peer, envelope, timeoutMs) {
+    return this.relay.sendRelay(peer.url, envelope, timeoutMs);
+  }
+
+  /**
+   * Receive a relayed ask/tell from a peer daemon. The route layer has already
+   * verified the signature and confirmed the sender is a configured peer, and
+   * passes the peer's alias for display. Resolves the target in the LOCAL
+   * registry and delivers with a guest sender identity.
+   *
+   * For 'ask' this resolves with the local agent's reply text (relayed back on
+   * the open response). For 'tell' it resolves once delivered; the reply is
+   * later queued to the outbox for the sending daemon.
+   */
+  async receiveRelay({ fromName, fromRole, fromDaemonId, peerAlias, toName, message, kind, threadId, timeoutMs }) {
+    // One hop only: a `name@peer` target here would be a second relay. Refuse
+    // before resolving, so it reads as "transitive" not "no such agent".
+    if (String(toName).includes('@')) throw new Error('Transitive relay refused — InnerChat is one hop only.');
+    const toAgent = this._resolveLocal(toName);
+    if (!toAgent) {
+      const names = this.daemon.registry.getAll().map((a) => a.name);
+      const err = new Error(`No agent named "${toName}" on this daemon.`);
+      err.availableAgents = names;
+      throw err;
+    }
+    if (this.awaiting.has(toAgent.id)) {
+      throw new Error(`${toAgent.name} is already answering another message — try again shortly.`);
+    }
+    if (!message || !message.trim()) throw new Error('message is required');
+
+    const guest = {
+      id: `guest:${fromDaemonId}:${fromName}`,
+      name: peerAlias ? `${fromName}@${peerAlias}` : fromName,
+      role: fromRole || 'remote-agent',
+      remote: { daemonId: fromDaemonId, fromName },
+    };
+
+    const t = this._openThread(guest, toAgent, threadId);
+    this._checkExchangeCap(t, toAgent);
+
+    const { targetId, skipResults } = await this._deliver(t, guest, toAgent, message.trim(), kind);
+
+    if (kind === 'tell') {
+      this.awaiting.set(targetId, {
+        mode: 'relay-async',
+        threadId: t.id,
+        remote: { forDaemonId: fromDaemonId, fromName },
+        skipResults,
+        timer: setTimeout(() => this._clearAwait(targetId), MAX_TIMEOUT_MS),
+      });
+      return { delivered: true, threadId: t.id };
+    }
+
+    const reply = await this._awaitReply(t, guest.id, targetId, {
+      skipResults,
+      timeoutMs: Math.min(Number(timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS),
+    });
+    return { reply, threadId: t.id };
+  }
+
+  // Local-only resolution mirroring the route resolver: exact id/name first,
+  // then a single unambiguous partial. Never reaches across daemons (one hop).
+  _resolveLocal(ref) {
+    const all = this.daemon.registry.getAll();
+    const needle = String(ref || '').trim().toLowerCase();
+    const exact = all.find((a) => a.id === ref)
+      || all.find((a) => a.name === ref)
+      || all.find((a) => a.name.toLowerCase() === needle);
+    if (exact) return exact;
+    const partial = all.filter((a) => a.name.toLowerCase() === needle
+      || a.name.toLowerCase().includes(needle));
+    return partial.length === 1 ? partial[0] : null;
+  }
+
+  // ── Outbox (async relay replies) ────────────────────────────
+
+  _enqueueOutbox(pending, answerTurn, text) {
+    this.relayOutbox.push({
+      id: randomUUID().slice(0, 12),
+      forDaemonId: pending.remote.forDaemonId,
+      toName: pending.remote.fromName,          // the remote agent that asked
+      fromName: answerTurn.from.name,            // the local agent that answered
+      fromDaemonId: this._daemonId(),
+      text,
+      threadId: pending.threadId,
+      ts: Date.now(),
+    });
+    this.daemon.audit.log('innerchat.relay.queued', { for: pending.remote.forDaemonId, from: answerTurn.from.name });
+  }
+
+  // Drain and remove outbox entries destined for a given daemon (at-least-once:
+  // removed on read). Called by the relay/outbox route after verifying the caller.
+  drainOutbox(forDaemonId) {
+    const mine = this.relayOutbox.filter((e) => e.forDaemonId === forDaemonId);
+    if (mine.length) this.relayOutbox = this.relayOutbox.filter((e) => e.forDaemonId !== forDaemonId);
+    return mine;
+  }
+
+  // Sender-side: poll a peer for queued replies until they stop arriving.
+  _ensureOutboxPoll(peer) {
+    const existing = this._outboxPollers.get(peer.alias);
+    if (existing) { existing.idle = 0; return; }
+
+    const state = { idle: 0, busy: false, timer: null };
+    const tick = async () => {
+      if (state.busy) return;
+      state.busy = true;
+      try {
+        const entries = await this._pollOutbox(peer);
+        if (entries.length) {
+          state.idle = 0;
+          for (const e of entries) await this._deliverRemoteReply(peer, e);
+        } else {
+          state.idle += 1;
+        }
+      } catch { state.idle += 1; }
+      finally { state.busy = false; }
+      if (state.idle >= OUTBOX_IDLE_STOP) this._stopOutboxPoll(peer.alias);
+    };
+    state.timer = setInterval(tick, OUTBOX_POLL_MS);
+    if (state.timer.unref) state.timer.unref();
+    this._outboxPollers.set(peer.alias, state);
+  }
+
+  async _pollOutbox(peer) {
+    const signed = this.daemon.federation.sign({ v: 1, type: 'innerchat.outbox', fromDaemonId: this._daemonId() });
+    const { json } = await this.relay.fetchOutbox(peer.url, { payload: signed.payload, signature: signed.signature }, 5000);
+    return Array.isArray(json?.entries) ? json.entries : [];
+  }
+
+  _stopOutboxPoll(alias) {
+    const state = this._outboxPollers.get(alias);
+    if (state?.timer) clearInterval(state.timer);
+    this._outboxPollers.delete(alias);
+  }
+
+  // Deliver a peer's async reply to the local agent that sent the original tell.
+  async _deliverRemoteReply(peer, entry) {
+    const sender = this._resolveLocal(entry.toName);
+    if (!sender) {
+      this.daemon.audit.log('innerchat.relay.reply_undeliverable', { to: entry.toName, peer: peer.alias });
+      return;
+    }
+    const msg = [
+      `[InnerChat reply from ${entry.fromName}@${peer.alias}]`,
+      '',
+      entry.text,
+      '',
+      'This is a reply to a message you sent earlier to a peer agent (you were not '
+      + 'blocking on it). Fold it into your work, or reply again to continue.',
+    ].join('\n');
+    try {
+      await deliverInstruction(this.daemon, sender.id, msg, { recordFeedback: false });
+    } catch (err) {
+      this.daemon.audit.log('innerchat.relay.reply_failed', { to: sender.id, error: err.message });
+    }
+  }
+
   // Clear all outstanding timers so a shutdown (or a test) doesn't hang on
   // pending ask/tell timeouts. Blocking asks are rejected so their HTTP
   // requests don't hang either.
@@ -404,6 +663,7 @@ export class InnerChat {
       this.awaiting.delete(targetId);
     }
     this.blockedOn.clear();
+    for (const alias of [...this._outboxPollers.keys()]) this._stopOutboxPoll(alias);
   }
 }
 

package/packages/daemon/src/introducer.js

@@ -561,7 +561,7 @@ export class Introducer {
   // compaction — the spawn prompt alone can scroll out of a long session.
   _innerChatSection() {
     const port = this.daemon.port || 31415;
-    return [...innerChatInstructions(port), '', ...watchInstructions(port), '', ...logFileInstructions()];
+    return [...innerChatInstructions(port, 'YOUR_NAME', this.daemon.config?.innerchatPeers), '', ...watchInstructions(port), '', ...logFileInstructions()];
   }
 
   writeRegistryFile(projectDir) {

package/packages/daemon/src/network-guard.js

@@ -0,0 +1,56 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { execFileSync } from 'child_process';
+
+// Fingerprint the current network by its default gateway's IP + MAC address.
+// The MAC is the strong part: it's unique to your router and a passive sniffer
+// on a coffee-shop LAN can't make their gateway look like your home router.
+// LAN peering only activates when this fingerprint matches the one recorded
+// when you enabled it at home — so at a hotel/cafe the peer listener never
+// opens in the first place.
+
+function defaultGatewayIp() {
+  try {
+    if (process.platform === 'darwin') {
+      const out = execFileSync('route', ['-n', 'get', 'default'], { encoding: 'utf8', timeout: 3000 });
+      const m = out.match(/gateway:\s*([\d.]+)/);
+      return m ? m[1] : null;
+    }
+    // linux
+    const out = execFileSync('ip', ['route'], { encoding: 'utf8', timeout: 3000 });
+    const m = out.match(/default via ([\d.]+)/);
+    return m ? m[1] : null;
+  } catch { return null; }
+}
+
+function macForIp(ip) {
+  if (!ip) return null;
+  try {
+    const arp = process.platform === 'darwin' ? ['-n', ip] : ['-n', ip];
+    const out = execFileSync('arp', arp, { encoding: 'utf8', timeout: 3000 });
+    // e.g. "? (10.0.0.1) at 5c:7d:7d:2d:11:e0 on en0 …"
+    const m = out.match(/([0-9a-f]{1,2}(:[0-9a-f]{1,2}){5})/i);
+    return m ? normalizeMac(m[1]) : null;
+  } catch { return null; }
+}
+
+function normalizeMac(mac) {
+  // ARP can print "5:7d:..." (no leading zero) — pad each octet so equality is reliable.
+  return mac.toLowerCase().split(':').map((o) => o.padStart(2, '0')).join(':');
+}
+
+// { gatewayIp, gatewayMac } for the network we're on right now, or nulls.
+export function currentNetworkFingerprint() {
+  const gatewayIp = defaultGatewayIp();
+  const gatewayMac = macForIp(gatewayIp);
+  return { gatewayIp, gatewayMac };
+}
+
+// Are we on the trusted network? Requires a MAC match — an IP-only match is not
+// enough (many LANs use 192.168.1.1). If no fingerprint was ever recorded, we
+// are NOT on a trusted network (fail closed).
+export function onTrustedNetwork(trusted) {
+  if (!trusted || !trusted.gatewayMac) return false;
+  const now = currentNetworkFingerprint();
+  return !!now.gatewayMac && now.gatewayMac === normalizeMac(trusted.gatewayMac);
+}

package/packages/daemon/src/process.js

@@ -71,7 +71,7 @@ Do NOT write code unless explicitly asked. Use your MCP tools (database queries,
 - Adapting tone and style to the audience (formal, conversational, technical, marketing)
 - Editing and polishing drafts for grammar, flow, and impact
 - Researching topics to produce accurate, substantive writing
-You CAN use code tools to create and edit text files, markdown documents, and structured content. For best results, apply a writing skill from the Marketplace that matches your task.
+You CAN use code tools to create and edit text files, markdown documents, and structured content. For best results, apply a writing skill from the Integrations tab that matches your task.
 
 `,
   chat: `You are a Chat agent — a conversational companion, friend, and assistant. You are warm, curious, and genuinely engaged. You can discuss anything: ideas, philosophy, science, culture, coding, life.
@@ -1196,7 +1196,7 @@ For normal file edits within your scope, proceed without review.
     if (!sandboxedProviders.includes(providerName) && !isOneShotProvider) {
       const port = this.daemon.port || 31415;
       const capabilities = [
-        ...innerChatInstructions(port, agent.name),
+        ...innerChatInstructions(port, agent.name, this.daemon.config?.innerchatPeers),
         '',
         ...watchInstructions(port, agent.name),
         '',

package/packages/daemon/src/providers/axom.js

@@ -0,0 +1,66 @@
+// GROOVE — Axom Provider (Endpoint Runtime)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Axom is an ENDPOINT provider, not a CLI provider: the runtime is a daemon
+// (`axom serve`, default port 8737) that GROOVE connects to over the Axom
+// provider protocol. Sessions stream envelope events; the AxomConnector
+// (src/axom-connector.js) owns the live connection. v0 has no session-create
+// verb, so agents are not spawnable — the Axom tab is the surface.
+
+import { Provider } from './base.js';
+import { AXOM_DEFAULT_PORT } from '../axom-connector.js';
+
+let _daemonRef = null;
+export function bindDaemon(daemon) { _daemonRef = daemon; }
+
+export class AxomProvider extends Provider {
+  static name = 'axom';
+  static displayName = 'Axom';
+  static command = 'axom';
+  static authType = 'endpoint'; // configured URL, no key — auth is a v1 protocol item
+  static managesOwnContext = true; // memory ledger + rotation live in the runtime
+  static singleTask = false;
+  static models = []; // the live roster comes from GET /about, not a static list
+
+  static isInstalled() {
+    return (_daemonRef?.config?.axom?.endpoints || []).length > 0;
+  }
+
+  // Settings renders this verbatim as text (string contract — Ollama's object
+  // shape only survives because its render branch never fires when installed).
+  static installCommand() {
+    return 'axom serve';
+  }
+
+  static async isServerRunning(url = `http://127.0.0.1:${AXOM_DEFAULT_PORT}`) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3000);
+      const res = await fetch(`${url.replace(/\/+$/, '')}/about`, { signal: controller.signal });
+      clearTimeout(timeout);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  buildSpawnCommand() {
+    throw new Error('Axom sessions are not spawnable in v0 — configure an endpoint and use the Axom tab');
+  }
+
+  buildHeadlessCommand() {
+    throw new Error('Axom has no headless command — it is an endpoint runtime, not a CLI');
+  }
+
+  static setupGuide() {
+    return {
+      installSteps: [
+        'Install the Axom runtime on the machine that will run it (localhost is the default topology)',
+        `Start it with: axom serve  (binds 127.0.0.1:${AXOM_DEFAULT_PORT})`,
+        'In GROOVE, open the Axom tab and add the endpoint URL',
+      ],
+      authMethods: [],
+      authInstructions: {},
+    };
+  }
+}

package/packages/daemon/src/providers/index.js

@@ -11,6 +11,7 @@ import { GrokProvider } from './grok.js';
 import { NanaBananaProvider } from './nano-banana.js';
 import { LocalProvider } from './local.js';
 import { GrooveNetworkProvider } from './groove-network.js';
+import { AxomProvider } from './axom.js';
 
 // Electron forks may not inherit the full shell PATH, causing `which` to miss
 // globally-installed CLI tools. Augment PATH with common npm global bin dirs.
@@ -90,6 +91,7 @@ const providers = {
   'nano-banana': new NanaBananaProvider(),
   'local': new LocalProvider(),
   'groove-network': new GrooveNetworkProvider(),
+  'axom': new AxomProvider(),
 };
 
 const installCache = new Map();

package/packages/daemon/src/routes/agents.js

@@ -2,9 +2,8 @@
 
 import { resolve } from 'path';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync } from 'fs';
-import { validateAgentConfig, validateReasoningEffort, validateVerbosity } from '../validate.js';
+import { validateAgentConfig } from '../validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from '../process.js';
-import { getProvider } from '../providers/index.js';
 import { deliverInstruction } from '../deliver.js';
 import { renameAgent } from '../rename.js';
 
@@ -218,179 +217,6 @@ export function registerAgentRoutes(app, daemon) {
     res.json(suggestion);
   });
 
-  // --- Conversations ---
-
-  app.get('/api/conversations', (req, res) => {
-    res.json({ conversations: daemon.conversations.list() });
-  });
-
-  app.post('/api/conversations', async (req, res) => {
-    try {
-      const { provider, model, title, mode, reasoning_effort, verbosity } = req.body;
-      if (provider && typeof provider !== 'string') {
-        return res.status(400).json({ error: 'provider must be a string' });
-      }
-      if (mode && mode !== 'api' && mode !== 'agent') {
-        return res.status(400).json({ error: 'mode must be "api" or "agent"' });
-      }
-      const validatedEffort = validateReasoningEffort(reasoning_effort);
-      const validatedVerbosity = validateVerbosity(verbosity);
-      const conversation = await daemon.conversations.create(provider, model, title, mode || 'api', {
-        reasoningEffort: validatedEffort,
-        verbosity: validatedVerbosity,
-      });
-      daemon.audit.log('conversation.create', { id: conversation.id, provider, model, mode: conversation.mode });
-      res.status(201).json(conversation);
-    } catch (err) {
-      res.status(400).json({ error: err.message });
-    }
-  });
-
-  app.get('/api/conversations/:id', (req, res) => {
-    const conversation = daemon.conversations.get(req.params.id);
-    if (!conversation) return res.status(404).json({ error: 'Conversation not found' });
-    res.json(conversation);
-  });
-
-  app.patch('/api/conversations/:id', async (req, res) => {
-    try {
-      const conv = daemon.conversations.get(req.params.id);
-      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
-      if (req.body.title !== undefined) daemon.conversations.rename(req.params.id, req.body.title);
-      if (req.body.pinned !== undefined) daemon.conversations.pin(req.params.id, req.body.pinned);
-      if (req.body.archived !== undefined) daemon.conversations.archive(req.params.id, req.body.archived);
-      if (req.body.model !== undefined || req.body.provider !== undefined) {
-        const newProvider = req.body.provider || conv.provider;
-        const newModel = req.body.model || conv.model;
-        daemon.conversations.updateModel(req.params.id, newProvider, newModel);
-      }
-      if (req.body.mode !== undefined) {
-        if (req.body.mode !== 'api' && req.body.mode !== 'agent') {
-          return res.status(400).json({ error: 'mode must be "api" or "agent"' });
-        }
-        await daemon.conversations.setMode(req.params.id, req.body.mode);
-      }
-      if (req.body.reasoning_effort !== undefined || req.body.verbosity !== undefined) {
-        const validatedEffort = req.body.reasoning_effort !== undefined ? validateReasoningEffort(req.body.reasoning_effort) : undefined;
-        const validatedVerbosity = req.body.verbosity !== undefined ? validateVerbosity(req.body.verbosity) : undefined;
-        daemon.conversations.updateReasoningSettings(req.params.id, validatedEffort, validatedVerbosity);
-      }
-      daemon.audit.log('conversation.update', { id: req.params.id, provider: req.body.provider, model: req.body.model, mode: req.body.mode });
-      res.json(daemon.conversations.get(req.params.id));
-    } catch (err) {
-      res.status(400).json({ error: err.message });
-    }
-  });
-
-  app.delete('/api/conversations/:id', async (req, res) => {
-    try {
-      const conv = daemon.conversations.get(req.params.id);
-      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
-      await daemon.conversations.delete(req.params.id);
-      daemon.audit.log('conversation.delete', { id: req.params.id });
-      res.json({ ok: true });
-    } catch (err) {
-      res.status(400).json({ error: err.message });
-    }
-  });
-
-  app.post('/api/conversations/:id/message', async (req, res) => {
-    try {
-      const { message, history, reasoning_effort, verbosity } = req.body;
-      if (!message || typeof message !== 'string' || !message.trim()) {
-        return res.status(400).json({ error: 'message is required' });
-      }
-      const validatedEffort = validateReasoningEffort(reasoning_effort);
-      const validatedVerbosity = validateVerbosity(verbosity);
-
-      const conv = daemon.conversations.get(req.params.id);
-      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
-
-      daemon.conversations.autoTitle(req.params.id, message.trim());
-      daemon.conversations.touchUpdatedAt(req.params.id);
-
-      await daemon.conversations.sendMessage(req.params.id, message.trim(), history || [], {
-        reasoningEffort: validatedEffort,
-        verbosity: validatedVerbosity,
-      });
-      daemon.audit.log('conversation.message', { id: req.params.id, mode: conv.mode || 'api' });
-      res.json({ status: 'streaming', mode: conv.mode || 'api' });
-    } catch (err) {
-      res.status(400).json({ error: err.message });
-    }
-  });
-
-  app.post('/api/conversations/:id/stop', (req, res) => {
-    try {
-      const conv = daemon.conversations.get(req.params.id);
-      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
-      daemon.conversations.stopStreaming(req.params.id);
-      res.json({ ok: true });
-    } catch (err) {
-      res.status(400).json({ error: err.message });
-    }
-  });
-
-  // --- Image Generation ---
-
-  app.post('/api/conversations/:id/generate-image', async (req, res) => {
-    try {
-      const { prompt, model, size, quality } = req.body;
-      if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
-        return res.status(400).json({ error: 'prompt is required' });
-      }
-      const conv = daemon.conversations.get(req.params.id);
-      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
-
-      let providerName = conv.provider;
-      let provider = getProvider(providerName);
-
-      // If a specific image model was requested, find the right provider
-      if (model) {
-        const imageProviders = ['codex', 'grok', 'nano-banana'];
-        for (const pid of imageProviders) {
-          const p = getProvider(pid);
-          if (p?.constructor.models.some((m) => m.id === model)) {
-            provider = p;
-            providerName = pid;
-            break;
-          }
-        }
-      }
-
-      if (!provider?.generateImage) {
-        return res.status(400).json({ error: 'Provider does not support image generation' });
-      }
-
-      const apiKey = daemon.conversations._getApiKey(providerName);
-      if (!apiKey) {
-        return res.status(400).json({ error: `No API key configured for ${providerName}` });
-      }
-
-      daemon.broadcast({
-        type: 'conversation:image-progress',
-        data: { conversationId: req.params.id, status: 'generating', prompt: prompt.trim() },
-      });
-
-      const result = await provider.generateImage(prompt.trim(), { model, size, quality, apiKey });
-
-      daemon.broadcast({
-        type: 'conversation:image',
-        data: { conversationId: req.params.id, ...result, prompt: prompt.trim() },
-      });
-
-      daemon.conversations.touchUpdatedAt(req.params.id);
-      daemon.audit.log('conversation.image', { id: req.params.id, model: result.model, provider: result.provider });
-      res.json(result);
-    } catch (err) {
-      daemon.broadcast({
-        type: 'conversation:image-progress',
-        data: { conversationId: req.params.id, status: 'error', error: err.message },
-      });
-      res.status(500).json({ error: err.message });
-    }
-  });
-
   // Stop an agent's current work without killing the agent
   app.post('/api/agents/:id/stop', async (req, res) => {
     try {