groove-dev 0.27.181 → 0.27.183

package/packages/daemon/src/process.js

@@ -320,10 +320,19 @@ 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);
 }
 
+// Agent log files are keyed by sanitized agent NAME, not id — a rotated agent
+// keeps its name and appends to the same file, preserving conversation history
+// across rotations. Every reader must resolve paths through this helper: an
+// id-based path silently misses the file and downstream consumers (handoff
+// briefs, conversation resume, synthesis) fall back to empty context.
+export function agentLogPath(grooveDir, agent) {
+  return resolve(grooveDir, 'logs', `${sanitizeFilename(agent.name)}.log`);
+}
+
 // Apply Claude Code billing mode to a spawn env, in place.
 // The `claude` CLI bills to usage credits when ANTHROPIC_API_KEY is present and
 // to the OAuth subscription otherwise. 'subscription' (default) strips any
@@ -1146,7 +1155,7 @@ For normal file edits within your scope, proceed without review.
     // Set up log capture (shared between CLI and agent loop paths)
     const logDir = resolve(this.daemon.grooveDir, 'logs');
     mkdirSync(logDir, { recursive: true });
-    const logPath = resolve(logDir, `${sanitizeFilename(agent.name)}.log`);
+    const logPath = agentLogPath(this.daemon.grooveDir, agent);
     const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
 
     // Inject API key from credential store for agent-loop providers
@@ -1567,38 +1576,54 @@ For normal file edits within your scope, proceed without review.
 
     // Session result data (cost, duration, turns)
     if (output.type === 'result') {
-      // Phantom-interrupt abort: on --resume with an orphaned background shell
-      // task, the CLI injects a synthetic "[Request interrupted by user]" that
-      // aborts the turn before the model is ever called. Fingerprint is an
-      // error result that never reached the API (apiDurationMs === 0, so zero
-      // cost). Retrying is free and succeeds ~94% of the time — treating it as
-      // a normal result is what made user messages vanish silently.
-      if (output.isError && output.apiDurationMs === 0) {
-        if (this._retryDroppedTurn(agentId, agent, output)) return;
-      }
-      // A turn completed for real — the user's message is safely delivered.
-      this._pendingUserMessage.delete(agentId);
-
-      tokens.recordResult(agentId, {
-        costUsd: output.cost, durationMs: output.duration, turns: output.turns,
-      });
-      if (output.cost) updates.costUsd = (agent.costUsd || 0) + output.cost;
-      if (output.duration) updates.durationMs = output.duration;
-      if (output.turns) updates.turns = output.turns;
-
-      // Claude Code sometimes hangs after emitting the result event — the
-      // process stays alive instead of exiting.  Record that the result
-      // arrived so exit handlers know this was a successful completion even
-      // if we have to SIGTERM the process.  After a 5s grace period, force-
-      // kill any process that hasn't exited on its own.
-      this._resultReceived.add(agentId);
-      const handle = this.handles.get(agentId);
-      if (handle?.proc && typeof handle.proc.kill === 'function') {
-        setTimeout(() => {
-          if (this.handles.has(agentId) && this._resultReceived.has(agentId)) {
-            try { handle.proc.kill('SIGTERM'); } catch {}
-          }
-        }, 5_000);
+      // Did this result represent a turn that actually ran? CLI >= 2.1.212
+      // emits a 0-turn no-op `result` during --resume reconciliation, before
+      // the real turn starts. Both it and an aborted turn report
+      // duration_api_ms === 0 — the model was never called. Providers that
+      // don't report an API duration (codex, gemini, ollama) are unaffected.
+      const reachedModel = output.apiDurationMs === undefined || output.apiDurationMs > 0;
+
+      // Turn aborted before the model was called — re-deliver the message.
+      // Deliberately does NOT return: session id persistence and the GUI
+      // broadcast below still need to run, and the retry is scheduled async.
+      if (!reachedModel && output.isError) {
+        this._retryDroppedTurn(agentId, agent, output);
+      }
+
+      // Everything below is completion bookkeeping and must only run for a
+      // turn that actually executed. Running it for the resume handshake is
+      // what killed the process mid-turn.
+      if (reachedModel) {
+        // The user's message is safely delivered.
+        this._pendingUserMessage.delete(agentId);
+
+        tokens.recordResult(agentId, {
+          costUsd: output.cost, durationMs: output.duration, turns: output.turns,
+        });
+        if (output.cost) updates.costUsd = (agent.costUsd || 0) + output.cost;
+        if (output.duration) updates.durationMs = output.duration;
+        if (output.turns) updates.turns = output.turns;
+
+        // Claude Code sometimes hangs after emitting the result event — the
+        // process stays alive instead of exiting.  Record that the result
+        // arrived so exit handlers know this was a successful completion even
+        // if we have to SIGTERM the process.  After a 5s grace period, force-
+        // kill any process that hasn't exited on its own.
+        //
+        // MUST stay behind the reachedModel guard. CLI >= 2.1.212 emits a
+        // 0-turn no-op result ~180ms into --resume; arming this on that result
+        // SIGTERMs the process ~5.2s later, mid-turn, before a token is
+        // produced (fable TTFT observed at 34s). The CLI records the signal as
+        // "[Request interrupted by user]" and the user's message is destroyed.
+        this._resultReceived.add(agentId);
+        const handle = this.handles.get(agentId);
+        if (handle?.proc && typeof handle.proc.kill === 'function') {
+          setTimeout(() => {
+            if (this.handles.has(agentId) && this._resultReceived.has(agentId)) {
+              try { handle.proc.kill('SIGTERM'); } catch {}
+            }
+          }, 5_000);
+        }
       }
     }
 

package/packages/daemon/src/providers/claude-code.js

@@ -275,7 +275,15 @@ export class ClaudeCodeProvider extends Provider {
 
     // Merge events: prefer content-bearing events (activity/result) over usage/session.
     // Accumulate token counts across all events in this chunk.
-    let content = events.find((e) => e.type === 'result') || events.find((e) => e.type === 'activity') || events[events.length - 1];
+    // Prefer an error result over a success one when a single chunk carries
+    // both. During --resume the CLI emits a 0-turn no-op success result
+    // immediately before the real turn's result; taking the first would hide a
+    // subsequent abort and the failure would look like a clean completion.
+    const resultEvents = events.filter((e) => e.type === 'result');
+    let content = resultEvents.find((e) => e.isError)
+      || resultEvents[0]
+      || events.find((e) => e.type === 'activity')
+      || events[events.length - 1];
     const merged = { ...content };
 
     let totalTokens = 0;

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/rotator.js

@@ -18,6 +18,9 @@ const SCORE_HISTORY_MAX = 40;   // ~10 min at 15s intervals
 const COOLDOWN_MS = 5 * 60 * 1000;   // 5 minutes between rotations per agent
 const QUALITY_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes for quality degradation rotations
 const TOKEN_CEILING = 5_000_000;     // 5M tokens per agent (non-self-managing only)
+const REPLAY_CEILING = 0.50;         // Self-managing providers: rotate idle agents above this context usage
+const VELOCITY_CEILING = 250_000;    // New (non-cache) tokens per window before force rotation
+const VELOCITY_WINDOW_MS = 5 * 60_000;
 const ROLE_MULTIPLIERS = {
   planner: 2,
   fullstack: 4,
@@ -201,13 +204,34 @@ export class Rotator extends EventEmitter {
       const singleTask = providerInstance?.constructor?.singleTask ?? false;
       if (singleTask) continue;
 
-      // Skip agents idle for over 60s — no point scoring them every 15s
-      const idleMs = this._idleMs(agent);
-      if (idleMs > 60_000 && agent.contextUsage < HARD_CEILING) continue;
-
       // Determine if provider manages its own context (e.g. Claude Code compacts internally)
       const selfManagesContext = providerInstance?.constructor?.managesOwnContext ?? false;
 
+      // Velocity safety — new-token burn rate, all provider types. tokensUsed
+      // excludes cache reads, so this measures real generation. Caps worst-case
+      // runaway burn; bypasses cooldown (a runaway must be stopped, not waited out).
+      const velCeiling = this.daemon.config?.velocityCeiling ?? VELOCITY_CEILING;
+      const velocity = this.daemon.tokens?.getVelocity?.(agent.id, VELOCITY_WINDOW_MS) ?? 0;
+      if (velCeiling > 0 && velocity >= velCeiling) {
+        console.warn(`  Rotator: ${agent.name} burned ${velCeiling.toLocaleString()}+ new tokens in 5min — FORCE rotating (velocity)`);
+        await this.rotate(agent.id, { reason: 'velocity_ceiling' });
+        continue;
+      }
+
+      // Replay ceiling — self-managing providers only. Internal compaction keeps
+      // sessions functional but lets context ride at 60-85% indefinitely, and every
+      // subsequent message replays that much context on EVERY API call in the agent
+      // loop. A handoff-brief rotation costs ~10K tokens once; riding high costs
+      // 150-300K per call. Computed here because the idle-skip guard below must
+      // not hide the exact agents this targets (idle, high-context).
+      const replayCeiling = this.daemon.config?.replayCeiling ?? REPLAY_CEILING;
+      const overReplayCeiling = selfManagesContext && replayCeiling > 0
+        && agent.contextUsage >= replayCeiling;
+
+      // Skip agents idle for over 60s — no point scoring them every 15s
+      const idleMs = this._idleMs(agent);
+      if (idleMs > 60_000 && agent.contextUsage < HARD_CEILING && !overReplayCeiling) continue;
+
       if (!selfManagesContext) {
         // Non-Claude: threshold + ceiling + quality rotation
         // These providers fill up linearly and degrade without external rotation
@@ -260,6 +284,13 @@ export class Rotator extends EventEmitter {
             continue;
           }
         }
+      } else if (overReplayCeiling && !this._isOnCooldown(agent.id) && idleMs > 10_000) {
+        // Rotate while idle only — never mid-task — and respect the cooldown.
+        // Continuity comes from the conversation-thread resume; rotate() blocks
+        // the rotation entirely if the thread can't be extracted for a chat agent.
+        console.log(`  Rotator: ${agent.name} at ${Math.round(agent.contextUsage * 100)}% — rotating (replay ceiling)`);
+        await this.rotate(agent.id, { reason: 'replay_ceiling' });
+        continue;
       }
 
       // --- Change 4: Truncation-triggered rotation ---
@@ -409,6 +440,7 @@ export class Rotator extends EventEmitter {
       // empty or the thread is too short to be useful.
       let brief;
       let usedConversationThread = false;
+      const isAutoRotation = options.reason && options.reason !== 'manual';
       if (typeof journalist.buildConversationResumePrompt === 'function') {
         const conversationPrompt = journalist.buildConversationResumePrompt(
           agent,
@@ -421,6 +453,22 @@ export class Rotator extends EventEmitter {
         }
       }
       if (!usedConversationThread) {
+        // Chat-continuity protection: an agent with a live user conversation must
+        // carry that dialogue into the fresh session. If the thread can't be
+        // extracted, a boilerplate brief would wipe the agent's memory of the
+        // conversation — skip the auto-rotation instead (context stays intact,
+        // worst case is status quo). Manual rotations proceed; the user accepts the risk.
+        if (isAutoRotation && this.userMessageTimes.has(agentId)) {
+          console.warn(`  Rotator: ${agent.name} has chat history but no extractable conversation thread — skipping rotation`);
+          this.rotating.delete(agentId);
+          this.daemon.broadcast({
+            type: 'rotation:blocked',
+            agentId,
+            agentName: agent.name,
+            reason: 'no_conversation_thread',
+          });
+          return null;
+        }
         brief = await journalist.generateHandoffBrief(agent, {
           reason: options.reason,
           qualityScore: options.qualityScore,
@@ -435,11 +483,14 @@ export class Rotator extends EventEmitter {
       // with too little meaningful content, the new agent will arrive blind.
       // Block it rather than spawning an agent that can't continue the work.
       // Manual rotations (user-requested) are never blocked — the user accepts the risk.
-      const isAutoRotation = options.reason && options.reason !== 'manual';
       if (isAutoRotation && !usedConversationThread) {
         const briefContent = brief
           .replace(/^#.*$/gm, '')           // strip markdown headers
           .replace(/^[-*].*role:.*$/gim, '') // strip metadata lines
+          // Strip the static Instructions boilerplate generateHandoffBrief always
+          // appends (~400 chars) — padding must not defeat the content threshold
+          .replace(/^- (Do NOT|If the task).*$/gm, '')
+          .replace(/^Continue and finish the in-progress task.*$/gm, '')
           .replace(/^\s*$/gm, '')           // strip blank lines
           .trim();
         if (briefContent.length < 200) {
@@ -716,6 +767,8 @@ export class Rotator extends EventEmitter {
     const hardCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'hard_ceiling').length;
     const tokenCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'token_ceiling').length;
     const estimatedCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'estimated_context_ceiling').length;
+    const replayCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'replay_ceiling').length;
+    const velocityCeilingRotations = this.rotationHistory.filter((r) => r.reason === 'velocity_ceiling').length;
     return {
       enabled: this.enabled,
       totalRotations,
@@ -726,6 +779,8 @@ export class Rotator extends EventEmitter {
       hardCeilingRotations,
       tokenCeilingRotations,
       estimatedCeilingRotations,
+      replayCeilingRotations,
+      velocityCeilingRotations,
       rotating: Array.from(this.rotating),
       liveScores: this.liveScores,
       scoreHistory: this.scoreHistory,
@@ -734,6 +789,8 @@ export class Rotator extends EventEmitter {
       qualityThreshold: QUALITY_THRESHOLD,
       cooldownMs: COOLDOWN_MS,
       tokenCeiling: TOKEN_CEILING,
+      replayCeiling: this.daemon.config?.replayCeiling ?? REPLAY_CEILING,
+      velocityCeiling: this.daemon.config?.velocityCeiling ?? VELOCITY_CEILING,
       roleMultipliers: ROLE_MULTIPLIERS,
     };
   }

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) {