groove-dev 0.27.184 → 0.27.186

package/packages/daemon/src/innerchat-docs.js

@@ -17,25 +17,80 @@ export function innerChatInstructions(port = 31415, agentName = 'YOUR_NAME') {
     'When the user asks you to reach out to, coordinate with, or get input from',
     'another agent, use this — it sends them a message and waits for their reply:',
     '',
+    '> **Do NOT use your built-in `SendMessage` / Agent tools to reach a GROOVE agent.**',
+    '> Those only address sub-agents you spawned yourself in this session, so they will',
+    '> fail with "not reachable" or ask you for an `a…-…` agent ID that does not exist',
+    '> here. GROOVE agents are separate processes. The curl below is the only way to',
+    '> reach them. Do not invent a fallback (writing a message into a file, etc.) —',
+    '> if the curl fails, read the error and report it to the user.',
+    '',
     '```bash',
     `curl -s http://localhost:${port}/api/innerchat/ask -X POST -H 'Content-Type: application/json' \\`,
     `  -d '{"from":"${agentName}","to":"AGENT_NAME","message":"YOUR_QUESTION"}'`,
     '```',
     '',
-    'The command BLOCKS until they answer, then returns:',
+    'This BLOCKS until they answer, then returns:',
     '`{"from":"...","reply":"...","exchangesUsed":N,"exchangesRemaining":N}`',
     '',
+    '> **Run the curl in the FOREGROUND and let it block.** Do not background it with',
+    "> `&`, and never put `&` inside the command — that detaches the curl and throws away",
+    "> the reply, so you get no answer and can't confirm delivery. Blocking for a minute or",
+    '> two is expected and correct; just wait for it. If you truly cannot wait, use `tell`',
+    '> (below) instead — that is the right tool for fire-and-forget, not a backgrounded ask.',
+    '',
     'Call it again to continue — prior turns are included automatically, so just say',
     'the next thing. Keep going until you reach a conclusion together, then report',
-    'that conclusion to the user.',
+    'that conclusion to the user. `ask` is best for tight back-and-forth (negotiating',
+    'an interface, resolving a blocker) where you need the answer before you proceed.',
+    '',
+    'If the other agent is heads-down and you do NOT need the answer right now, send it',
+    'without blocking instead — this returns immediately, and their reply (if any) is',
+    'delivered back to you later, waking you if your turn has ended:',
+    '',
+    '```bash',
+    `curl -s http://localhost:${port}/api/innerchat/tell -X POST -H 'Content-Type: application/json' \\`,
+    `  -d '{"from":"${agentName}","to":"AGENT_NAME","message":"YOUR_MESSAGE"}'`,
+    '```',
     '',
     '**Rules:**',
     '- Only start a conversation when the user asks you to. Never consult other agents on your own initiative.',
     `- \`from\` must be your own agent name${agentName === 'YOUR_NAME' ? ' (it is in your $GROOVE_AGENT_NAME environment variable)' : ''}.`,
     '- Agent names are listed in `AGENTS_REGISTRY.md`, including agents on other teams.',
-    '- One question per call. Wait for the answer before deciding what to ask next.',
+    '- Use `ask` when you need the reply now; use `tell` to hand off or notify without waiting.',
+    '- One message per call. With `ask`, wait for the answer before deciding what to ask next.',
+    '- Ground truth lives in files (specs, code, run output), not in chat — use InnerChat to',
+    '  negotiate and hand off, and verify claims against the actual artifacts.',
     '- Read any error you get back — it tells you what to do (unknown name, cap reached, or they are waiting on you).',
-    '- `exchangesRemaining` counts down. At 0 the conversation is over: stop and report what you have.',
-    '- If another agent asks YOU something, answer it directly in your next message. They are blocked until you do.',
+    '- `exchangesRemaining` counts down (shared by ask and tell). At 0 the conversation is over: stop and report.',
+    '- If another agent asks YOU something (a blocking ask), answer it directly in your next message — they are blocked until you do.',
+  ];
+}
+
+// Wake-on-completion. Same delivery/injection story as InnerChat above.
+export function watchInstructions(port = 31415, agentName = 'YOUR_NAME') {
+  const nameHint = agentName === 'YOUR_NAME' ? ' ($GROOVE_AGENT_NAME)' : '';
+  return [
+    '## Getting Notified When Something Finishes (Watch)',
+    '',
+    'Your process ends when your turn ends, so a test suite or long job you kicked',
+    'off has nothing to notify you — telling the user "I\'ll report back when it lands"',
+    'does not work on its own; the session is gone. Instead, set a Watch. The daemon',
+    'outlives your turn and RESUMES you with the result when it finishes:',
+    '',
+    '```bash',
+    `curl -s http://localhost:${port}/api/watch -X POST -H 'Content-Type: application/json' \\`,
+    `  -d '{"agent":"${agentName}","label":"test suite","command":"npm test"}'`,
+    '```',
+    '',
+    'This returns immediately with a `watchId`. **End your turn** — you will be woken',
+    'with the exit code and output tail when the command finishes.',
+    '',
+    '- Prefer `command` (let the daemon run it) over launching it yourself — that way',
+    '  it captures the real exit code and output.',
+    '- For something ALREADY running, poll instead with `until` (fires when the check',
+    `  exits 0): \`-d '{"agent":"${agentName}","label":"server up","until":"curl -sf localhost:3000/health"}'\`.`,
+    `- \`agent\` must be your own name${nameHint}.`,
+    '- Watches time out (default 30 min). One clear task per watch; do not watch trivial commands you could just run.',
+    '- Do not poll or sleep-loop waiting yourself — set the watch and end the turn. That is the whole point.',
   ];
 }

package/packages/daemon/src/innerchat.js

@@ -65,81 +65,127 @@ export class InnerChat {
       throw new Error(`${toAgent.name} is already answering another agent — try again shortly`);
     }
 
-    const thread = opts.threadId ? this.threads.get(opts.threadId) : this._findThread(fromAgentId, toAgentId);
-    const t = thread || this._createThread(fromAgent, toAgent);
+    const t = this._openThread(fromAgent, toAgent, opts.threadId);
+    this._checkExchangeCap(t, toAgent);
 
-    const exchanges = t.turns.filter((x) => x.kind === 'ask').length;
-    if (exchanges >= MAX_EXCHANGES) {
-      throw new Error(
-        `This conversation has reached its ${MAX_EXCHANGES}-exchange limit. Stop consulting `
-        + `${toAgent.name} and report your conclusion to the user.`,
-      );
+    const timeoutMs = Math.min(Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+
+    const { turn, targetId, skipResults } = await this._deliver(t, fromAgent, toAgent, message.trim(), 'ask');
+    this.daemon.audit.log('innerchat.ask', { thread: t.id, from: fromAgentId, to: targetId });
+
+    const reply = await this._awaitReply(t, fromAgentId, targetId, { skipResults, timeoutMs });
+    const exchanges = t.turns.filter((x) => x.kind === 'ask' || x.kind === 'tell').length;
+
+    return { reply, threadId: t.id, exchanges, remaining: MAX_EXCHANGES - exchanges };
+  }
+
+  /**
+   * Send a message to another agent WITHOUT blocking. Returns as soon as it's
+   * delivered. If the target later replies, the reply is routed back to the
+   * sender asynchronously — resuming the sender if its turn has ended.
+   *
+   * This is the fire-and-forget counterpart to ask(): use it to hand off to an
+   * agent that's heads-down, where waiting out a timeout would waste the turn.
+   */
+  async tell(fromAgentId, toAgentId, message, opts = {}) {
+    const fromAgent = this.daemon.registry.get(fromAgentId);
+    const toAgent = this.daemon.registry.get(toAgentId);
+    if (!fromAgent) throw new Error(`Calling agent ${fromAgentId} not found`);
+    if (!toAgent) throw new Error(`Target agent ${toAgentId} not found`);
+    if (fromAgentId === toAgentId) throw new Error('An agent cannot message itself');
+    if (!message || !message.trim()) throw new Error('message is required');
+    if (this.awaiting.has(toAgentId)) {
+      throw new Error(`${toAgent.name} already has an unanswered message — wait for its reply before sending another`);
     }
 
-    const timeoutMs = Math.min(Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    const t = this._openThread(fromAgent, toAgent, opts.threadId);
+    this._checkExchangeCap(t, toAgent);
 
+    const { turn, targetId, skipResults } = await this._deliver(t, fromAgent, toAgent, message.trim(), 'tell');
+    this.daemon.audit.log('innerchat.tell', { thread: t.id, from: fromAgentId, to: targetId });
+
+    // Register async capture: the reply (if any) is forwarded, not awaited.
+    this.awaiting.set(targetId, {
+      mode: 'async',
+      threadId: t.id,
+      senderId: fromAgentId,
+      skipResults,
+      timer: setTimeout(() => this._clearAwait(targetId), MAX_TIMEOUT_MS),
+    });
+
+    const exchanges = t.turns.filter((x) => x.kind === 'ask' || x.kind === 'tell').length;
+    return { delivered: true, threadId: t.id, exchanges, remaining: MAX_EXCHANGES - exchanges };
+  }
+
+  // Shared send: push a turn, deliver it, and remap the target id if delivery
+  // resumed/rotated the agent. Returns the queued-skip count for reply capture.
+  async _deliver(thread, fromAgent, toAgent, message, kind) {
     const turn = {
       id: randomUUID().slice(0, 12),
       from: peer(fromAgent),
       to: peer(toAgent),
-      text: message.trim(),
-      kind: 'ask',
+      text: message,
+      kind,
       status: 'sending',
       timestamp: Date.now(),
     };
-    t.turns.push(turn);
+    thread.turns.push(turn);
 
-    const wrapped = this._wrap(t, fromAgent, toAgent, message.trim());
+    const wrapped = this._wrap(thread, fromAgent, toAgent, message, kind);
 
     let result;
     try {
-      result = await deliverInstruction(this.daemon, toAgentId, wrapped, { recordFeedback: false });
+      result = await deliverInstruction(this.daemon, toAgent.id, wrapped, { recordFeedback: false });
     } catch (err) {
       turn.status = 'failed';
       turn.error = err.message;
-      t.status = 'failed';
-      this._broadcast(t, turn);
+      thread.status = 'failed';
+      this._broadcast(thread, turn);
       throw new Error(`Could not reach ${toAgent.name}: ${err.message}`);
     }
 
-    // A stopped target gets resumed or rotated, which mints a new agent id.
-    // Re-key onto it or the answer will never be matched.
+    // A stopped target gets resumed or rotated, minting a new agent id.
     const targetId = result.agentId;
-    if (targetId !== toAgentId) {
-      this._remapParticipant(t, toAgentId, targetId);
+    if (targetId !== toAgent.id) {
+      this._remapParticipant(thread, toAgent.id, targetId);
       turn.to.id = targetId;
     }
 
     turn.status = result.status;
-    t.status = 'awaiting_reply';
-    t.updatedAt = Date.now();
-    this._broadcast(t, turn);
-    this.daemon.audit.log('innerchat.ask', { thread: t.id, from: fromAgentId, to: targetId });
+    thread.status = 'awaiting_reply';
+    thread.updatedAt = Date.now();
+    this._broadcast(thread, turn);
 
-    // A queued question sits behind whatever the target 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;
+    // A queued message sits behind the target's current work, so the next
+    // result belongs to that prior task, not to us — skip it.
+    return { turn, targetId, skipResults: result.status === 'message_queued' ? 1 : 0 };
+  }
 
-    const reply = await this._awaitReply(t, fromAgentId, targetId, { skipResults, timeoutMs });
+  _openThread(fromAgent, toAgent, threadId) {
+    const thread = threadId ? this.threads.get(threadId) : this._findThread(fromAgent.id, toAgent.id);
+    return thread || this._createThread(fromAgent, toAgent);
+  }
 
-    return {
-      reply,
-      threadId: t.id,
-      exchanges: exchanges + 1,
-      remaining: MAX_EXCHANGES - (exchanges + 1),
-    };
+  _checkExchangeCap(thread, toAgent) {
+    const used = thread.turns.filter((x) => x.kind === 'ask' || x.kind === 'tell').length;
+    if (used >= MAX_EXCHANGES) {
+      throw new Error(
+        `This conversation has reached its ${MAX_EXCHANGES}-exchange limit. Stop consulting `
+        + `${toAgent.name} and report your conclusion to the user.`,
+      );
+    }
   }
 
   _awaitReply(thread, askerId, targetId, { skipResults, timeoutMs }) {
     return new Promise((resolve, reject) => {
       const settle = (fn, value) => {
-        clearTimeout(record.timer);
-        this.awaiting.delete(targetId);
+        this._clearAwait(targetId);
         this.blockedOn.delete(askerId);
         fn(value);
       };
 
       const record = {
+        mode: 'block',
         threadId: thread.id,
         askerId,
         skipResults,
@@ -150,7 +196,7 @@ export class InnerChat {
           thread.updatedAt = Date.now();
           record.reject(new Error(
             `No answer within ${Math.round(timeoutMs / 1000)}s. The agent may still be working — `
-            + 'proceed on your own judgement or try again.',
+            + 'proceed on your own judgement, or use a non-blocking send (tell) next time.',
           ));
         }, timeoutMs),
       };
@@ -161,7 +207,7 @@ export class InnerChat {
   }
 
   /**
-   * Watch agent output for the answer to an outstanding question.
+   * Watch agent output for the reply to an outstanding message.
    * Called from the process manager's output handler.
    */
   onAgentOutput(agentId, output) {
@@ -170,7 +216,7 @@ export class InnerChat {
     if (output.type !== 'result') return;
 
     const thread = this.threads.get(pending.threadId);
-    if (!thread) { pending.reject(new Error('Conversation was lost')); return; }
+    if (!thread) { this._settlePending(agentId, pending, null, new Error('Conversation was lost')); return; }
 
     const text = extractText(output.data);
     if (!text) return;
@@ -182,7 +228,7 @@ export class InnerChat {
     }
 
     const responder = this.daemon.registry.get(agentId);
-    thread.turns.push({
+    const answerTurn = {
       id: randomUUID().slice(0, 12),
       from: responder ? peer(responder) : { id: agentId, name: agentId, role: 'agent' },
       to: this._otherParticipant(thread, agentId),
@@ -190,27 +236,67 @@ export class InnerChat {
       kind: 'answer',
       status: 'delivered',
       timestamp: Date.now(),
-    });
+    };
+    thread.turns.push(answerTurn);
     thread.status = 'idle';
     thread.updatedAt = Date.now();
-
-    this._broadcast(thread, thread.turns.at(-1));
+    this._broadcast(thread, answerTurn);
     this.daemon.audit.log('innerchat.answer', { thread: thread.id, from: agentId });
 
-    pending.resolve(text);
+    if (pending.mode === 'async') {
+      this._clearAwait(agentId);
+      this._forwardAsyncReply(pending, answerTurn, text);
+    } else {
+      pending.resolve(text);
+    }
+  }
+
+  // Deliver an async (tell) reply back to the original sender, resuming it if
+  // its turn has ended. The sender is not blocked, so this just wakes them.
+  async _forwardAsyncReply(pending, answerTurn, text) {
+    const sender = this.daemon.registry.get(pending.senderId)
+      || this.daemon.registry.getAll().find((a) => a.name === answerTurn.to.name);
+    if (!sender) return; // sender is gone — nothing to route back to
+
+    const msg = [
+      `[InnerChat reply from ${answerTurn.from.name} (${answerTurn.from.role})]`,
+      '',
+      text,
+      '',
+      'This is a reply to a message you sent earlier (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.forward_failed', { to: sender.id, error: err.message });
+    }
   }
 
   /**
-   * An agent that dies mid-question would otherwise leave its asker blocked
-   * until the timeout. Called when an agent crashes or is killed.
+   * An agent that dies mid-question would otherwise leave a blocking asker
+   * stuck until timeout. Async senders aren't waiting, so just clear those.
    */
   onAgentGone(agentId, reason = 'stopped') {
     const pending = this.awaiting.get(agentId);
     if (!pending) return;
+    if (pending.mode === 'async') { this._clearAwait(agentId); return; }
     const agent = this.daemon.registry.get(agentId);
     pending.reject(new Error(`${agent?.name || agentId} ${reason} before answering`));
   }
 
+  _clearAwait(targetId) {
+    const pending = this.awaiting.get(targetId);
+    if (pending?.timer) clearTimeout(pending.timer);
+    this.awaiting.delete(targetId);
+  }
+
+  _settlePending(agentId, pending, value, err) {
+    if (pending.mode === 'async') { this._clearAwait(agentId); return; }
+    if (err) pending.reject(err); else pending.resolve(value);
+  }
+
   // ── Threads ─────────────────────────────────────────────────
 
   _createThread(fromAgent, toAgent) {
@@ -233,10 +319,15 @@ export class InnerChat {
   }
 
   // The target sees a direct message from the other agent, with enough prior
-  // turns to follow a continuing conversation.
-  _wrap(thread, fromAgent, toAgent, message) {
+  // turns to follow a continuing conversation. The closing instruction differs
+  // by kind: an ask blocks the sender (answer now), a tell does not (answer
+  // when you reach a good stopping point).
+  _wrap(thread, fromAgent, toAgent, message, kind = 'ask') {
+    const header = kind === 'tell'
+      ? `[InnerChat — ${fromAgent.name} (${fromAgent.role}) sent you a message]`
+      : `[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`;
     const prior = thread.turns.slice(0, -1).slice(-CONTEXT_TURNS);
-    const lines = [`[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`, ''];
+    const lines = [header, ''];
 
     if (prior.length) {
       lines.push('Earlier in this conversation:');
@@ -245,11 +336,19 @@ export class InnerChat {
     }
 
     lines.push(message, '');
-    lines.push(
-      `${fromAgent.name} is BLOCKED waiting on your answer — it cannot continue until you `
-      + 'respond. Answer directly and concisely in your next message; that message is sent '
-      + 'back to it verbatim. Do not address the user, and do not start unrelated work first.',
-    );
+    if (kind === 'tell') {
+      lines.push(
+        `${fromAgent.name} is NOT blocked on this — finish what you're doing first if you're `
+        + 'mid-task. When you reach a good stopping point, answer directly in a message; your '
+        + `reply is relayed back to ${fromAgent.name}. If no reply is needed, just carry on.`,
+      );
+    } else {
+      lines.push(
+        `${fromAgent.name} is BLOCKED waiting on your answer — it cannot continue until you `
+        + 'respond. Answer directly and concisely in your next message; that message is sent '
+        + 'back to it verbatim. Do not address the user, and do not start unrelated work first.',
+      );
+    }
     return lines.join('\n');
   }
 
@@ -286,6 +385,20 @@ export class InnerChat {
     const pending = this.awaiting.get(agentId);
     return pending ? this.threads.get(pending.threadId) : null;
   }
+
+  // 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.
+  stop() {
+    for (const [targetId, pending] of this.awaiting) {
+      if (pending.timer) clearTimeout(pending.timer);
+      if (pending.mode === 'block') {
+        try { pending.reject(new Error('Daemon shutting down')); } catch { /* already settled */ }
+      }
+      this.awaiting.delete(targetId);
+    }
+    this.blockedOn.clear();
+  }
 }
 
 function peer(agent) {

package/packages/daemon/src/introducer.js

@@ -4,7 +4,7 @@
 import { writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, dirname, basename } from 'path';
 import { escapeMd } from './validate.js';
-import { innerChatInstructions } from './innerchat-docs.js';
+import { innerChatInstructions, watchInstructions } from './innerchat-docs.js';
 
 const GROOVE_SECTION_START = '<!-- GROOVE:START -->';
 const GROOVE_SECTION_END = '<!-- GROOVE:END -->';
@@ -560,7 +560,8 @@ export class Introducer {
   // Written into every AGENTS_REGISTRY.md so the capability survives context
   // compaction — the spawn prompt alone can scroll out of a long session.
   _innerChatSection() {
-    return innerChatInstructions(this.daemon.port || 31415);
+    const port = this.daemon.port || 31415;
+    return [...innerChatInstructions(port), '', ...watchInstructions(port)];
   }
 
   writeRegistryFile(projectDir) {

package/packages/daemon/src/journalist.js

@@ -10,6 +10,12 @@ import { agentLogPath } from './process.js';
 const DEFAULT_INTERVAL = 300_000; // 5 minutes (safety-net fallback; event-driven triggers handle the normal case)
 const MAX_LOG_CHARS = 100_000; // ~25k tokens budget for synthesis input (captures 80-90% of recent activity)
 const DEBOUNCE_MS = 10_000; // requestSynthesis debounce window
+// Conversation carried across a rotation (~37K tokens at 150K chars). This is
+// deliberately generous: a rotation is the one lossy step in an infinite
+// session, and re-reading the recent dialogue once per rotation is far cheaper
+// than the degradation from an agent that forgot its own history. Tune via
+// config resumeBudgetChars (lower for cost-sensitive fleets).
+const DEFAULT_RESUME_BUDGET_CHARS = 150_000;
 
 export class Journalist {
   constructor(daemon) {
@@ -1061,7 +1067,51 @@ export class Journalist {
    *
    * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
    */
-  extractConversationThread(agent, { maxChars = 60000 } = {}) {
+  extractConversationThread(agent, { maxChars } = {}) {
+    // Budget is configurable (resumeBudgetChars): this is the "how much memory
+    // survives a rotation" dial. Bigger costs more tokens per rotation but
+    // preserves more of the session; a rotation is lossy exactly here.
+    if (!maxChars) maxChars = this.daemon.config?.resumeBudgetChars ?? DEFAULT_RESUME_BUDGET_CHARS;
+    const merged = this._parseConversationTurns(agent);
+    if (!merged || merged.length === 0) return null;
+
+    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
+    let thread = '';
+    const formatted = merged.map((t) => {
+      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
+      return `[${label}]:\n${t.text}`;
+    });
+
+    // Start from the end (most recent) and work backwards to fill budget
+    const recentFirst = [...formatted].reverse();
+    const kept = [];
+    let totalLen = 0;
+
+    for (const entry of recentFirst) {
+      if (totalLen + entry.length > maxChars) {
+        // Truncate this entry to fit remaining budget
+        const remaining = maxChars - totalLen;
+        if (remaining > 200) {
+          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
+        }
+        break;
+      }
+      kept.push(entry);
+      totalLen += entry.length;
+    }
+
+    // Reverse back to chronological order
+    kept.reverse();
+    thread = kept.join('\n\n---\n\n');
+
+    return thread;
+  }
+
+  /**
+   * Parse the full user↔assistant turn list from an agent's stream-json log.
+   * Returns merged turns in chronological order, or null if no log/turns.
+   */
+  _parseConversationTurns(agent) {
     const logPath = agentLogPath(this.daemon.grooveDir, agent);
     if (!existsSync(logPath)) return null;
 
@@ -1121,37 +1171,23 @@ export class Journalist {
         merged.push({ ...turn });
       }
     }
+    return merged;
+  }
 
-    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
-    let thread = '';
-    const formatted = merged.map((t) => {
-      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
-      return `[${label}]:\n${t.text}`;
-    });
-
-    // Start from the end (most recent) and work backwards to fill budget
-    const recentFirst = [...formatted].reverse();
-    const kept = [];
-    let totalLen = 0;
-
-    for (const entry of recentFirst) {
-      if (totalLen + entry.length > maxChars) {
-        // Truncate this entry to fit remaining budget
-        const remaining = maxChars - totalLen;
-        if (remaining > 200) {
-          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
-        }
-        break;
-      }
-      kept.push(entry);
-      totalLen += entry.length;
-    }
-
-    // Reverse back to chronological order
-    kept.reverse();
-    thread = kept.join('\n\n---\n\n');
-
-    return thread;
+  /**
+   * The agent's ORIGINAL task, from the first substantial user message in the
+   * FULL log — never from the truncated resume window. When weeks of dialogue
+   * exceed the resume budget, the window holds only recent work; anchoring the
+   * task there makes the agent's identity drift onto whatever happened last.
+   * The name-keyed log spans all rotations, so the true origin is always here.
+   */
+  extractOriginalTask(agent) {
+    const merged = this._parseConversationTurns(agent);
+    if (!merged) return '';
+    const first = merged.find((t) => t.role === 'user' && t.text.trim().length >= 10);
+    if (!first) return '';
+    const text = first.text.trim();
+    return text.length > 500 ? text.slice(0, 500) + '...' : text;
   }
 
   /**
@@ -1159,15 +1195,17 @@ export class Journalist {
    * thread so a fresh agent picks up where the previous session left off.
    */
   buildConversationResumePrompt(agent, userMessage, { isRotation = false, reason } = {}) {
-    const thread = this.extractConversationThread(agent);
+    const budget = this.daemon.config?.resumeBudgetChars ?? DEFAULT_RESUME_BUDGET_CHARS;
+    const thread = this.extractConversationThread(agent, { maxChars: budget });
     if (!thread) return null;
 
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
     const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 5, 1000, agent.scope, agent.teamId) || '';
 
-    // Extract the user's original task from the conversation — the first substantial
-    // user message is almost always the task assignment. This anchors the new agent.
-    const originalTask = this._extractOriginalTask(thread);
+    // Anchor the agent to its ORIGINAL task from the full log — the truncated
+    // thread's first message may be mid-project (or another agent's task) once
+    // history outgrows the budget. Fall back to the window only if the log parse fails.
+    const originalTask = this.extractOriginalTask(agent) || this._extractOriginalTask(thread);
 
     // Rotation and idle-resume need very different framing. During rotation the agent
     // has no new user message — it must continue the exact in-progress task without
@@ -1181,6 +1219,7 @@ export class Journalist {
       originalTask ? `Your task: ${originalTask}` : '',
       ``,
       `Rules:`,
+      `- NEVER mention the rotation, context refresh, restart, or any session discontinuity to the user — from the user's perspective you are one continuous agent and this refresh must be invisible`,
       `- Continue ONLY the task described in the conversation below`,
       `- Do NOT explore the codebase looking for other things to fix or improve`,
       `- Do NOT start new work that was not part of the original task`,
@@ -1210,14 +1249,16 @@ export class Journalist {
       isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
       ``,
       isRotation
-        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything. If the task was already completed, state that and wait for new instructions.`
-        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
+        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything, and never reference this context refresh — continue as if the conversation above simply never stopped. If the task was already completed, state that and wait for new instructions.`
+        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything, and never mention the interruption or that you are resuming — to the user this is one continuous conversation.`,
     ].filter(Boolean).join('\n');
 
-    // Hard cap at 80K chars (~20K tokens) to leave plenty of room in context window
-    if (prompt.length > 80000) {
+    // Cap scales with the configured budget (framing adds constraints/discoveries
+    // on top of the thread) to leave room in the context window
+    const promptCap = budget + 20_000;
+    if (prompt.length > promptCap) {
       // Re-extract with smaller budget and rebuild
-      const smallerThread = this.extractConversationThread(agent, { maxChars: 40000 });
+      const smallerThread = this.extractConversationThread(agent, { maxChars: Math.floor(budget * 2 / 3) });
       if (smallerThread) {
         prompt = [
           `# Session Context Resume`,
@@ -1238,8 +1279,8 @@ export class Journalist {
           isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
           ``,
           isRotation
-            ? `Continue the in-progress task only. Do not explore or start new work. If done, state that and wait.`
-            : `Continue seamlessly. Do not ask the user to repeat anything.`,
+            ? `Continue the in-progress task only. Do not explore or start new work. Never mention this context refresh to the user. If done, state that and wait.`
+            : `Continue seamlessly. Do not ask the user to repeat anything, and never mention the interruption — to the user this is one continuous conversation.`,
         ].filter(Boolean).join('\n');
       }
     }