groove-dev 0.27.182 → 0.27.183

package/packages/daemon/src/index.js

@@ -10,7 +10,7 @@ import express from 'express';
 import { WebSocketServer } from 'ws';
 import { Registry } from './registry.js';
 import { createApi } from './api.js';
-import { ProcessManager } from './process.js';
+import { ProcessManager, sanitizeFilename } from './process.js';
 import { StateManager } from './state.js';
 import { Introducer } from './introducer.js';
 import { LockManager } from './lockmanager.js';
@@ -750,7 +750,11 @@ export class Daemon {
     try {
       // Build set of agent names still in the registry — never remove their logs
       const allAgents = this.registry.getAll();
-      const activeNames = new Set(allAgents.map((a) => a.name));
+      // Raw logs are keyed by sanitized name; GROOVE_AGENT_LOGS/ subdirectories
+      // are keyed by agent id (journalist.js). Comparing either against the
+      // wrong set deletes live agents' history.
+      const activeNames = new Set(allAgents.map((a) => sanitizeFilename(a.name)));
+      const activeIds = new Set(allAgents.map((a) => a.id));
 
       // Safety: if registry is empty but log files exist, state may have been
       // lost (corrupt JSON, partial write). Skip log cleanup to prevent
@@ -778,7 +782,7 @@ export class Daemon {
       if (existsSync(agentLogsDir)) {
         for (const dir of readdirSync(agentLogsDir, { withFileTypes: true })) {
           if (!dir.isDirectory()) continue;
-          if (activeNames.has(dir.name)) continue;
+          if (activeIds.has(dir.name)) continue;
           try { rmSync(resolve(agentLogsDir, dir.name), { recursive: true }); cleaned++; } catch { /* skip */ }
         }
         // Remove GROOVE_AGENT_LOGS/ itself if empty

package/packages/daemon/src/innerchat.js

@@ -1,100 +1,251 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { randomUUID } from 'crypto';
-
+import { deliverInstruction } from './deliver.js';
+
+// How much prior conversation to replay into each relay turn. Enough for the
+// recipient to pick up the thread without re-reading the whole exchange.
+const CONTEXT_TURNS = 4;
+const MAX_TURN_CHARS = 1200;
+
+/**
+ * Agent-to-agent relay, user-initiated.
+ *
+ * The A→B hop is always driven by a human clicking Relay. The B→A hop is
+ * automatic: B's answer is fed straight back into A so A can process it and
+ * report to the user, who then decides whether to run another turn.
+ *
+ * Delivery goes through deliverInstruction — the same pipe as user chat — so
+ * a relay reaches its target whether it's mid-task, idle, or stopped.
+ */
 export class InnerChat {
   constructor(daemon) {
     this.daemon = daemon;
-    this.messages = new Map();
-    this.pendingResponses = new Map();
+    this.threads = new Map();
+    // agentId -> { threadId, sentAt } — which agent we're awaiting a reply from.
+    this.awaiting = new Map();
   }
 
-  async send(fromAgentId, toAgentId, message) {
+  /**
+   * Relay a message from one agent to another, opening a thread or continuing
+   * an existing one.
+   */
+  async send(fromAgentId, toAgentId, message, threadId = null) {
     const fromAgent = this.daemon.registry.get(fromAgentId);
     const toAgent = this.daemon.registry.get(toAgentId);
     if (!fromAgent) throw new Error(`Sender agent ${fromAgentId} not found`);
     if (!toAgent) throw new Error(`Target agent ${toAgentId} not found`);
-
-    const id = randomUUID().slice(0, 12);
-    const msg = {
-      id,
-      from: { id: fromAgent.id, name: fromAgent.name, role: fromAgent.role },
-      to: { id: toAgent.id, name: toAgent.name, role: toAgent.role },
-      message,
-      response: null,
-      status: 'sent',
+    if (fromAgentId === toAgentId) throw new Error('Cannot relay an agent to itself');
+    if (!message || !message.trim()) throw new Error('message is required');
+
+    const thread = threadId ? this.threads.get(threadId) : null;
+    if (threadId && !thread) throw new Error(`Thread ${threadId} not found`);
+
+    const t = thread || this._createThread(fromAgent, toAgent);
+    const turn = {
+      id: randomUUID().slice(0, 12),
+      from: peer(fromAgent),
+      to: peer(toAgent),
+      text: message.trim(),
+      kind: 'relay',
+      status: 'sending',
       timestamp: Date.now(),
-      respondedAt: null,
     };
+    t.turns.push(turn);
+
+    const wrapped = this._wrap(t, fromAgent, toAgent, message.trim());
+
+    let result;
+    try {
+      result = await deliverInstruction(this.daemon, toAgentId, wrapped, { recordFeedback: false });
+    } catch (err) {
+      turn.status = 'failed';
+      turn.error = err.message;
+      t.status = 'failed';
+      this.daemon.broadcast({ type: 'innerchat:turn', data: { thread: t, turn } });
+      throw err;
+    }
 
-    this.messages.set(id, msg);
-    this.pendingResponses.set(toAgentId, id);
+    // A stopped target gets resumed or rotated, which mints a new agent id.
+    // Re-key everything onto it or the reply will never be captured.
+    if (result.agentId !== toAgentId) {
+      this._remapParticipant(t, toAgentId, result.agentId);
+      turn.to.id = result.agentId;
+    }
 
-    const wrapped = `[InnerChat from ${fromAgent.name} (${fromAgent.role})]\n\n${message}\n\nReply normally — your response will be relayed back to ${fromAgent.name}.`;
+    turn.status = result.status;
+    t.status = 'awaiting_reply';
+    t.updatedAt = Date.now();
 
-    let deliveryStatus = 'sent';
-    if (this.daemon.processes.hasAgentLoop(toAgentId)) {
-      const sent = await this.daemon.processes.sendMessage(toAgentId, wrapped, 'agent');
-      deliveryStatus = sent ? 'delivered' : 'queued';
-    } else if (this.daemon.processes.isRunning(toAgentId)) {
-      this.daemon.processes.queueMessage(toAgentId, wrapped);
-      deliveryStatus = 'queued';
-    } else {
-      throw new Error(`Target agent ${toAgent.name} is not running`);
-    }
+    // A queued relay sits behind whatever the agent is already doing, so the
+    // next result belongs to that prior task, not to us — skip it.
+    const skipResults = result.status === 'message_queued' ? 1 : 0;
+    this.awaiting.set(turn.to.id, { threadId: t.id, sentAt: Date.now(), skipResults });
 
-    msg.status = deliveryStatus;
-    this.daemon.broadcast({ type: 'innerchat:sent', data: msg });
-    this.daemon.audit.log('innerchat.send', { id, from: fromAgentId, to: toAgentId });
+    this.daemon.broadcast({ type: 'innerchat:turn', data: { thread: t, turn } });
+    this.daemon.audit.log('innerchat.send', { thread: t.id, from: fromAgentId, to: turn.to.id });
 
-    return msg;
+    return { thread: t, turn };
   }
 
+  /**
+   * Watch agent output for the reply to an outstanding relay, then forward it
+   * back to the agent that asked.
+   */
   onAgentOutput(agentId, output) {
-    const messageId = this.pendingResponses.get(agentId);
-    if (!messageId) return;
+    const pending = this.awaiting.get(agentId);
+    if (!pending) return;
     if (output.type !== 'result') return;
 
-    const msg = this.messages.get(messageId);
-    if (!msg) return;
+    const thread = this.threads.get(pending.threadId);
+    if (!thread) { this.awaiting.delete(agentId); return; }
+
+    const responseText = extractText(output.data);
+    if (!responseText) return;
+
+    // Burn off results belonging to work that was already underway when the
+    // relay was queued behind it.
+    if (pending.skipResults > 0) {
+      pending.skipResults -= 1;
+      return;
+    }
+
+    // Claim the reply before the async forward so a second result arriving
+    // mid-flight can't be captured as a duplicate.
+    this.awaiting.delete(agentId);
 
-    let responseText = '';
-    if (typeof output.data === 'string') {
-      responseText = output.data;
-    } else if (Array.isArray(output.data)) {
-      responseText = output.data.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    const responder = this.daemon.registry.get(agentId);
+    const asker = this._otherParticipant(thread, agentId);
+
+    const turn = {
+      id: randomUUID().slice(0, 12),
+      from: responder ? peer(responder) : { id: agentId, name: agentId, role: 'agent' },
+      to: asker,
+      text: responseText,
+      kind: 'reply',
+      status: 'forwarding',
+      timestamp: Date.now(),
+    };
+    thread.turns.push(turn);
+    thread.status = 'forwarding';
+    thread.updatedAt = Date.now();
+
+    this._forwardReply(thread, turn, asker.id, responseText);
+  }
+
+  async _forwardReply(thread, turn, askerId, responseText) {
+    const from = turn.from;
+    const relay = [
+      `[InnerChat reply from ${from.name} (${from.role})]`,
+      '',
+      responseText,
+      '',
+      `This is the answer to what you relayed to ${from.name}. Process it and report back — `
+        + 'the user will decide whether to send another turn.',
+    ].join('\n');
+
+    try {
+      const result = await deliverInstruction(this.daemon, askerId, relay, { recordFeedback: false });
+      if (result.agentId !== askerId) {
+        this._remapParticipant(thread, askerId, result.agentId);
+        turn.to.id = result.agentId;
+      }
+      turn.status = result.status;
+      thread.status = 'idle';
+    } catch (err) {
+      turn.status = 'failed';
+      turn.error = err.message;
+      thread.status = 'failed';
     }
-    if (!responseText.trim()) return;
-
-    msg.response = responseText.trim();
-    msg.status = 'responded';
-    msg.respondedAt = Date.now();
-    this.pendingResponses.delete(agentId);
-
-    const relay = `[InnerChat reply from ${msg.to.name} (${msg.to.role})]\n\n${msg.response}`;
-    const senderId = msg.from.id;
-    if (this.daemon.processes.hasAgentLoop(senderId)) {
-      this.daemon.processes.sendMessage(senderId, relay, 'agent').catch(() => {});
-    } else if (this.daemon.processes.isRunning(senderId)) {
-      this.daemon.processes.queueMessage(senderId, relay);
+
+    thread.updatedAt = Date.now();
+    this.daemon.broadcast({ type: 'innerchat:turn', data: { thread, turn } });
+    this.daemon.audit.log('innerchat.reply', { thread: thread.id, from: turn.from.id, to: turn.to.id });
+  }
+
+  // ── Thread helpers ──────────────────────────────────────────
+
+  _createThread(fromAgent, toAgent) {
+    const thread = {
+      id: randomUUID().slice(0, 12),
+      participants: [peer(fromAgent), peer(toAgent)],
+      turns: [],
+      status: 'idle',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+    this.threads.set(thread.id, thread);
+    return thread;
+  }
+
+  // Rebuild the message the target sees. It reads as a direct message from the
+  // other agent, with enough prior turns that a continuing thread makes sense.
+  _wrap(thread, fromAgent, toAgent, message) {
+    const prior = thread.turns.slice(0, -1).slice(-CONTEXT_TURNS);
+    const lines = [`[InnerChat from ${fromAgent.name} (${fromAgent.role})]`, ''];
+
+    if (prior.length) {
+      lines.push('Earlier in this conversation:');
+      for (const t of prior) {
+        lines.push(`  ${t.from.name}: ${truncate(t.text, MAX_TURN_CHARS)}`);
+      }
+      lines.push('');
     }
 
-    this.daemon.broadcast({ type: 'innerchat:response', data: msg });
-    this.daemon.audit.log('innerchat.response', { id: messageId, from: msg.from.id, to: msg.to.id });
+    lines.push(message, '');
+    lines.push(
+      `Reply normally — your response is relayed straight back to ${fromAgent.name}. `
+      + 'Answer them directly; do not address the user.',
+    );
+    return lines.join('\n');
+  }
+
+  _otherParticipant(thread, agentId) {
+    return thread.participants.find((p) => p.id !== agentId) || thread.participants[0];
+  }
+
+  _remapParticipant(thread, oldId, newId) {
+    for (const p of thread.participants) {
+      if (p.id === oldId) p.id = newId;
+    }
+    // Any relay still awaiting a reply from the old id must follow it forward.
+    const pending = this.awaiting.get(oldId);
+    if (pending) {
+      this.awaiting.delete(oldId);
+      this.awaiting.set(newId, pending);
+    }
   }
 
-  getMessages(agentId = null) {
-    const all = Array.from(this.messages.values());
+  // ── Queries ─────────────────────────────────────────────────
+
+  getThreads(agentId = null) {
+    const all = Array.from(this.threads.values()).sort((a, b) => b.updatedAt - a.updatedAt);
     if (!agentId) return all;
-    return all.filter(m => m.from.id === agentId || m.to.id === agentId);
+    return all.filter((t) => t.participants.some((p) => p.id === agentId));
   }
 
-  getMessage(id) {
-    return this.messages.get(id) || null;
+  getThread(id) {
+    return this.threads.get(id) || null;
   }
 
   getPending(agentId) {
-    const messageId = this.pendingResponses.get(agentId);
-    return messageId ? this.messages.get(messageId) : null;
+    const pending = this.awaiting.get(agentId);
+    return pending ? this.threads.get(pending.threadId) : null;
+  }
+}
+
+function peer(agent) {
+  return { id: agent.id, name: agent.name, role: agent.role };
+}
+
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max)}… [truncated]`;
+}
+
+function extractText(data) {
+  if (typeof data === 'string') return data.trim();
+  if (Array.isArray(data)) {
+    return data.filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
   }
+  return '';
 }

package/packages/daemon/src/process.js

@@ -320,7 +320,7 @@ const PERMISSION_PROMPTS = {
   supervised: null,  // Maps to auto (supervised removed — too expensive)
 };
 
-function sanitizeFilename(name) {
+export function sanitizeFilename(name) {
   return String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
 }
 

package/packages/daemon/src/registry.js

@@ -79,12 +79,16 @@ export class Registry extends EventEmitter {
     return Array.from(this.agents.values());
   }
 
-  update(id, updates) {
+  update(id, updates, { allowRename = false } = {}) {
     const agent = this.agents.get(id);
     if (!agent) return null;
 
     // Only allow known fields to prevent prototype pollution
     for (const key of Object.keys(updates)) {
+      // Logs, personalities and agent-files are keyed by name — renaming
+      // without migrating them orphans the lot, and the GC then deletes it.
+      // renameAgent() (rename.js) does the migration and opts in here.
+      if (key === 'name' && !allowRename) continue;
       if (SAFE_FIELDS.has(key)) {
         agent[key] = updates[key];
       }

package/packages/daemon/src/rename.js

@@ -0,0 +1,72 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { resolve } from 'path';
+import { existsSync, renameSync } from 'fs';
+import { sanitizeFilename } from './process.js';
+
+/**
+ * Rename an agent, migrating everything keyed by its name.
+ *
+ * Agent logs, personalities and scratch files are keyed by NAME rather than id
+ * on purpose — rotation mints a new id, and name-keying is what carries an
+ * agent's history across it (see agentLogPath in process.js). The cost is that
+ * a bare rename orphans all of it, and the log GC then deletes the orphan. So
+ * a rename has to move those artifacts itself.
+ *
+ * Note the live process keeps the old name in its env (GROOVE_AGENT_NAME) and
+ * system prompt until it next respawns — the daemon-side view is what changes.
+ */
+export function renameAgent(daemon, agentId, newName) {
+  const agent = daemon.registry.get(agentId);
+  if (!agent) throw new Error('Agent not found');
+
+  const trimmed = String(newName || '').trim();
+  if (!trimmed) throw new Error('name is required');
+
+  // The name becomes a path segment (agent-files/<name>, personalities/<name>.md),
+  // so anything with a separator or a dot-segment would escape the directory.
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed) || /^\.+$/.test(trimmed)) {
+    throw new Error('name may only contain letters, numbers, dots, dashes and underscores');
+  }
+  if (trimmed.length > 64) throw new Error('name must be 64 characters or fewer');
+
+  if (trimmed === agent.name) return agent;
+
+  // Two agents sharing a name means two agents sharing one log file.
+  const collision = daemon.registry.getAll()
+    .some((a) => a.id !== agentId && a.name === trimmed);
+  if (collision) throw new Error(`An agent named ${trimmed} already exists`);
+
+  const oldName = agent.name;
+  const { grooveDir, projectDir } = daemon;
+
+  const moves = [
+    // Raw log — the one whose loss breaks chat resume and synthesis.
+    [resolve(grooveDir, 'logs', `${sanitizeFilename(oldName)}.log`),
+     resolve(grooveDir, 'logs', `${sanitizeFilename(trimmed)}.log`)],
+    [resolve(grooveDir, 'personalities', `${oldName}.md`),
+     resolve(grooveDir, 'personalities', `${trimmed}.md`)],
+    [resolve(projectDir, 'agent-files', oldName),
+     resolve(projectDir, 'agent-files', trimmed)],
+  ];
+
+  const moved = [];
+  try {
+    for (const [from, to] of moves) {
+      if (!existsSync(from) || existsSync(to)) continue;
+      renameSync(from, to);
+      moved.push([from, to]);
+    }
+  } catch (err) {
+    // Roll back so a partial migration can't leave artifacts split across
+    // two names — that's the state the GC would then eat.
+    for (const [from, to] of moved.reverse()) {
+      try { renameSync(to, from); } catch { /* best effort */ }
+    }
+    throw new Error(`Rename failed while migrating files: ${err.message}`);
+  }
+
+  const updated = daemon.registry.update(agentId, { name: trimmed }, { allowRename: true });
+  daemon.audit.log('agent.rename', { id: agentId, from: oldName, to: trimmed });
+  return updated;
+}

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

@@ -5,6 +5,8 @@ import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSy
 import { validateAgentConfig, validateReasoningEffort, validateVerbosity } 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';
 
 export function registerAgentRoutes(app, daemon) {
   // List all agents
@@ -56,9 +58,21 @@ export function registerAgentRoutes(app, daemon) {
 
   // Update agent
   app.patch('/api/agents/:id', (req, res) => {
-    const agent = daemon.registry.update(req.params.id, req.body);
-    if (!agent) return res.status(404).json({ error: 'Agent not found' });
-    res.json(agent);
+    try {
+      const { name, ...rest } = req.body || {};
+
+      // Renames migrate name-keyed files, so they can't go through the plain
+      // field update — registry.update ignores `name` without the opt-in.
+      let agent = daemon.registry.get(req.params.id);
+      if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+      if (Object.keys(rest).length) agent = daemon.registry.update(req.params.id, rest);
+      if (typeof name === 'string') agent = renameAgent(daemon, req.params.id, name);
+
+      res.json(agent);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
   });
 
   // Kill an agent (add ?purge=true to also remove from registry)
@@ -426,104 +440,12 @@ export function registerAgentRoutes(app, daemon) {
         }
       }
 
-      // Record user feedback so the journalist can include it in future agent context
-      if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, finalMessage);
-      if (daemon.rotator) daemon.rotator.recordUserMessage(req.params.id);
-
-      // Agent loop path — send message directly to the running loop
-      const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
-      if (daemon.processes.hasAgentLoop(req.params.id)) {
-        const sent = await daemon.processes.sendMessage(req.params.id, wrappedMessage);
-        if (sent) {
-          daemon.audit.log('agent.chat', { id: req.params.id });
-          return res.json({ id: agent.id, status: 'message_sent' });
-        }
-        // Loop exists but not running — fall through to resume/rotate
-      }
-
-      // One-shot providers (groove-network): kill any running instance and
-      // respawn with the user's message as --prompt. No handoff brief, no
-      // session resume, no message queue — each chat message is a fresh spawn.
-      const provider = getProvider(agent.provider);
-      if (provider?.constructor?.isOneShot) {
-        const oldConfig = { ...agent };
-        if (daemon.processes.isRunning(req.params.id)) {
-          await daemon.processes.kill(req.params.id);
-        }
-        daemon.registry.remove(req.params.id, { silent: true });
-        daemon.locks.release(req.params.id);
-
-        let newAgent;
-        try {
-          newAgent = await daemon.processes.spawn({
-            role: oldConfig.role,
-            scope: oldConfig.scope,
-            provider: oldConfig.provider,
-            model: oldConfig.model,
-            prompt: finalMessage,
-            permission: oldConfig.permission || 'full',
-            workingDir: oldConfig.workingDir,
-            name: oldConfig.name,
-            teamId: oldConfig.teamId,
-          });
-        } catch (spawnErr) {
-          daemon.registry.flushPendingRemovals();
-          throw spawnErr;
-        }
-        daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
-        return res.json(newAgent);
-      }
-
-      // Non-interactive CLI providers (e.g. Gemini): respawn with the new
-      // message as the prompt, preserving original introContext. These providers
-      // run one prompt per spawn and cannot resume sessions.
-      if (provider?.constructor?.nonInteractive && !daemon.processes.isRunning(req.params.id)) {
-        const oldConfig = { ...agent };
-        daemon.registry.remove(req.params.id, { silent: true });
-        daemon.locks.release(req.params.id);
-
-        let newAgent;
-        try {
-          newAgent = await daemon.processes.spawn({
-            role: oldConfig.role,
-            scope: oldConfig.scope,
-            provider: oldConfig.provider,
-            model: oldConfig.model,
-            prompt: finalMessage,
-            introContext: oldConfig.introContext,
-            permission: oldConfig.permission || 'full',
-            workingDir: oldConfig.workingDir,
-            name: oldConfig.name,
-            teamId: oldConfig.teamId,
-          });
-        } catch (spawnErr) {
-          daemon.registry.flushPendingRemovals();
-          throw spawnErr;
-        }
-        daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
-        return res.json(newAgent);
-      }
-
-      // Running CLI agent (no loop) — queue the message for delivery after
-      // the current task completes instead of killing and respawning.
-      if (daemon.processes.isRunning(req.params.id)) {
-        daemon.processes.queueMessage(req.params.id, wrappedMessage);
-        daemon.audit.log('agent.chat.queued', { id: req.params.id });
-        return res.json({ id: agent.id, status: 'message_queued' });
-      }
+      const result = await deliverInstruction(daemon, req.params.id, finalMessage);
 
-      // CLI agent path — session resume or rotation.
-      // Force rotation (fresh session + handoff brief) past the resume ceiling:
-      // reviving a >5M-token claude session has crashed the CLI mid-HTTP-parse
-      // (V8 fatal in JsonStringifier) — the rotator's handoff brief sidesteps that.
-      const SESSION_RESUME_CEILING = 5_000_000;
-      const resumed = !!agent.sessionId && (agent.tokensUsed || 0) < SESSION_RESUME_CEILING;
-      const newAgent = resumed
-        ? await daemon.processes.resume(req.params.id, wrappedMessage)
-        : await daemon.rotator.rotate(req.params.id, { additionalPrompt: wrappedMessage });
-
-      daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed });
-      res.json(newAgent);
+      // Respawn paths return the fresh agent record; in-place delivery just
+      // acknowledges with a status the GUI uses to show queued vs sent.
+      if (result.agent && result.agentId !== req.params.id) return res.json(result.agent);
+      res.json({ id: agent.id, status: result.status });
     } catch (err) {
       res.status(400).json({ error: err.message });
     }

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

@@ -1,30 +1,33 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 export function registerInnerChatRoutes(app, daemon) {
+  // Relay a message from one agent to another. Opens a thread, or continues
+  // an existing one when threadId is supplied.
   app.post('/api/innerchat/send', async (req, res) => {
     try {
-      const { from, to, message } = req.body;
+      const { from, to, message, threadId } = req.body;
       if (!from || typeof from !== 'string') return res.status(400).json({ error: 'from (agent ID) is required' });
       if (!to || typeof to !== 'string') return res.status(400).json({ error: 'to (agent ID) is required' });
       if (!message || typeof message !== 'string' || !message.trim()) return res.status(400).json({ error: 'message is required' });
       if (from === to) return res.status(400).json({ error: 'cannot send a message to yourself' });
+      if (threadId && typeof threadId !== 'string') return res.status(400).json({ error: 'threadId must be a string' });
 
-      const msg = await daemon.innerchat.send(from, to, message.trim());
-      res.json(msg);
+      const result = await daemon.innerchat.send(from, to, message.trim(), threadId || null);
+      res.json(result);
     } catch (err) {
       res.status(400).json({ error: err.message });
     }
   });
 
-  app.get('/api/innerchat/messages', (req, res) => {
+  app.get('/api/innerchat/threads', (req, res) => {
     const { agentId } = req.query;
-    res.json({ messages: daemon.innerchat.getMessages(agentId || null) });
+    res.json({ threads: daemon.innerchat.getThreads(agentId || null) });
   });
 
-  app.get('/api/innerchat/messages/:id', (req, res) => {
-    const msg = daemon.innerchat.getMessage(req.params.id);
-    if (!msg) return res.status(404).json({ error: 'Message not found' });
-    res.json(msg);
+  app.get('/api/innerchat/threads/:id', (req, res) => {
+    const thread = daemon.innerchat.getThread(req.params.id);
+    if (!thread) return res.status(404).json({ error: 'Thread not found' });
+    res.json(thread);
   });
 
   app.get('/api/innerchat/pending/:agentId', (req, res) => {

package/packages/daemon/src/teams.js

@@ -148,11 +148,17 @@ export class Teams {
           renameSync(oldWorkingDir, newWorkingDir);
           team.workingDir = newWorkingDir;
 
-          // Update all agents in this team with the new working directory
+          // Repoint every agent under the old tree, not just those sitting at
+          // its root — an agent in a subdirectory would otherwise keep a path
+          // that no longer exists.
           const agents = this.daemon.registry.getAll().filter((a) => a.teamId === id);
           for (const agent of agents) {
+            if (!agent.workingDir) continue;
             if (agent.workingDir === oldWorkingDir) {
               this.daemon.registry.update(agent.id, { workingDir: newWorkingDir });
+            } else if (agent.workingDir.startsWith(`${oldWorkingDir}/`)) {
+              const suffix = agent.workingDir.slice(oldWorkingDir.length);
+              this.daemon.registry.update(agent.id, { workingDir: `${newWorkingDir}${suffix}` });
             }
           }
         } catch (err) {