mixdog 1.3.2 → 1.3.4

package/src/runtime/agent/orchestrator/providers/custom-provider-config.mjs

@@ -58,7 +58,15 @@ function strictPositiveInt(value, label) {
   return value;
 }
 
-const OVERRIDE_KEYS = new Set(['manual', 'hidden', 'name', 'contextWindow', 'maxOutputTokens', 'reasoning']);
+const OVERRIDE_KEYS = new Set([
+  'manual',
+  'hidden',
+  'name',
+  'contextWindow',
+  'maxOutputTokens',
+  'supportsVision',
+  'reasoning',
+]);
 const REASONING_KEYS = new Set(['levels', 'wireFormat', 'wireValues', 'replay']);
 const DISCOVERY_KEYS = new Set(['newModelsHidden']);
 // v2 config fields, plus the transport fields callers pass alongside them and
@@ -220,6 +228,9 @@ function normalizeOverride(id, raw, protocol, legacy) {
   if (contextWindow) out.contextWindow = contextWindow;
   const maxOutputTokens = positiveInt(raw.maxOutputTokens, `${label}.maxOutputTokens`);
   if (maxOutputTokens) out.maxOutputTokens = maxOutputTokens;
+  // Tri-state image input: absent = auto (catalog / default), true / false = the user's word.
+  const supportsVision = optionalBoolean(raw.supportsVision, `${label}.supportsVision`);
+  if (supportsVision !== undefined) out.supportsVision = supportsVision;
   if (raw.reasoning !== undefined) {
     const reasoning = normalizeReasoning(raw.reasoning, `${label}.reasoning`, protocol);
     if (Object.keys(reasoning).length) out.reasoning = reasoning;
@@ -420,6 +431,8 @@ function effectiveRow(base, override, { providerId, discovered, newModelsHidden
     outputTokens: ov.maxOutputTokens ?? (Number(base.outputTokens) > 0 ? Number(base.outputTokens) : null),
     hidden,
     manual: ov.manual === true,
+    // An explicit override (false included) beats the catalog; unset keeps the base.
+    ...(typeof ov.supportsVision === 'boolean' ? { supportsVision: ov.supportsVision } : {}),
     supportsReasoning: levels ? levels.some((level) => level !== 'none') : base.supportsReasoning === true,
     ...reasoningLevelFields(levels),
     customReasoning: { wireFormat: reasoning.wireFormat ?? 'standard', wireValues, replay },

package/src/runtime/agent/orchestrator/providers/grok-client-version.mjs

@@ -3,7 +3,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // Grok CLI client version for the cli-chat-proxy version gate (HTTP 426).
 // Effective = env override, else max(floor, learned-from-426, live npm latest
 // of the official @xai-official/grok CLI).
-export const GROK_CLI_VERSION_FLOOR = '1.0.62';
+export const GROK_CLI_VERSION_FLOOR = '1.0.67';
 export const GROK_CLI_NPM_PACKAGE = '@xai-official/grok';
 
 const live = createNpmVersionSource(GROK_CLI_NPM_PACKAGE, { persistKey: 'grok-cli' });

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -518,6 +518,16 @@ export function providerNativePdf(name) {
 export function providerReadsImages(name) {
   return providers.get(String(name || '').toLowerCase())?.takesImages !== false;
 }
+/**
+ * The user's image-input override for one model of a custom provider: true or
+ * false as set, undefined when unset (auto) or the provider is not a loaded
+ * custom one. A pure lookup; it never instantiates a provider.
+ */
+export function providerModelVisionOverride(name, model) {
+  const overrides = providers.get(String(name || '').toLowerCase())?.customConfig?.modelOverrides;
+  const value = overrides && Object.hasOwn(overrides, model) ? overrides[model]?.supportsVision : undefined;
+  return typeof value === 'boolean' ? value : undefined;
+}
 /**
  * Whether the named provider's adapter declares `consumesReadWindows`: it
  * needs the structured clip report of read results. A pure lookup; a proxy

package/src/runtime/agent/orchestrator/providers/wire-gateway.mjs

@@ -9,7 +9,7 @@ import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs
 import { originBoundFetch } from './lib/origin-bound-fetch.mjs';
 import { withInclusiveUsage } from './lib/inclusive-usage.mjs';
 import { getModelMetadataSync } from './model-catalog.mjs';
-import { resolveWireRoute, sendOnRoute } from './wire-route.mjs';
+import { resolveWireRoute, sendOnRoute, sendWireRoute } from './wire-route.mjs';
 
 // A Files API file-ID image anywhere in the history (tool results nest content).
 function hasFileIdImage(value, depth = 0) {
@@ -66,6 +66,10 @@ export class GatewayMessagesEngine extends AnthropicProvider {
   _sendOnce(messages, model, tools, opts) {
     return super._sendOnce(messages, model, tools, gatewayMessagesOpts(this.config, model, messages, opts));
   }
+  // Same ceiling a send resolves, so a retry never asks above the gateway's limit.
+  escalatedMaxTokens(model, opts) {
+    return super.escalatedMaxTokens(model, gatewayMessagesOpts(this.config, model, [], opts));
+  }
   _createClient(apiKey) {
     const client = super._createClient(apiKey);
     if (this.config.authScheme === 'bearer') {
@@ -138,6 +142,14 @@ export class WireGatewayProvider {
     });
   }
 
+  // A higher one-shot max_tokens exists only on the Messages wire; the
+  // route is the same one the send itself resolves. Other wires: null.
+  async escalatedMaxTokens(model, opts, tools) {
+    const useModel = model || this.openai.defaultModel;
+    const route = await sendWireRoute(this, useModel, tools, opts);
+    return route?.wire === 'messages' ? this.anthropic.escalatedMaxTokens(useModel, opts) : null;
+  }
+
   reloadApiKey() {
     this.openai.reloadApiKey();
     this.anthropic.reloadApiKey();

package/src/runtime/agent/orchestrator/runtime-core/goal-runtime.mjs

@@ -65,6 +65,10 @@ export function createGoalRuntime({
     // context still owes, from the rules and state already delivered into it.
     // In memory on purpose: a restart is a fresh context that needs them again.
     continuationTiers: new Map(),
+    // Session -> Goal id whose turn ended in a stop (failed, cancelled, usage
+    // limit) the record could not save. The record still reads active, so
+    // without this a full disk would start turn after turn into the same error.
+    unsavedStops: new Map(),
     closed: false,
   };
   Object.assign(ctx, createGoalStore(ctx));
@@ -116,6 +120,7 @@ export function createGoalRuntime({
       ctx.observedGoals.clear();
       ctx.idleReviewTurns.clear();
       ctx.continuationTiers.clear();
+      ctx.unsavedStops.clear();
       listeners.clear();
       // Accepted writes keep their ordering until they settle. Callers may
       // await this barrier before releasing the session's backing resources.

package/src/runtime/agent/orchestrator/runtime-core/goal-turns.mjs

@@ -114,6 +114,7 @@ export function createGoalTurnLifecycle(ctx) {
     turnStartedAt,
     idleReviewTurns,
     continuationTiers,
+    unsavedStops,
     withMutation,
     readRecord,
     commit,
@@ -163,7 +164,14 @@ export function createGoalTurnLifecycle(ctx) {
           applyTurnOutcome(goal, detail, at);
         }
         goal.updatedAt = at;
-        const published = await commit(id, goal);
+        let published;
+        try {
+          published = await commit(id, goal);
+        } catch (error) {
+          if (goal.status !== 'active') unsavedStops.set(id, goal.id);
+          throw error;
+        }
+        unsavedStops.delete(id);
         if (automaticTurnWithoutActivity(detail, published)) idleReviewTurns.set(id, idleReviewKey(published));
         return published;
       });
@@ -189,6 +197,7 @@ export function createGoalTurnLifecycle(ctx) {
       if (goal?.status !== 'active') return { run: false, reason: goal?.status || 'missing', goal };
       if (runningAgentWork(agentStatus)) return { run: false, reason: 'agent-running', goal };
       const id = assertSessionId(sessionId);
+      if (unsavedStops.get(id) === goal.id) return { run: false, reason: 'unsaved-stop', goal };
       const answered = idleReviewTurns.get(id) === idleReviewKey(goal);
       if (settledDurationWait(goal)) {
         // The model already answered this exact list with no new work, so the

package/src/runtime/agent/orchestrator/runtime-core/tool-catalog.mjs

@@ -622,6 +622,18 @@ function reconcileStateMatches(a, b) {
   return true;
 }
 
+// Tools whose schema the session itself keeps exposed: the active surface and
+// the callable/discovered state. Session fields, so a compaction keeps them;
+// discoveries known only from message history (native tool references) are
+// not here, since compaction can remove that history.
+function persistentToolSurfaceNames(session) {
+  return new Set([
+    ...(session.tools || []).map((tool) => clean(tool?.name)).filter(Boolean),
+    ...parseToolSelection(session.deferredCallableTools),
+    ...parseToolSelection(session.deferredDiscoveredTools),
+  ]);
+}
+
 function reconcileDeferredMcpToolCatalogUncached(session, liveMcpTools) {
   const live = filterDisallowedTools(Array.isArray(liveMcpTools) ? liveMcpTools : [], session.disallowedTools);
   const hadSnapshot = Array.isArray(session.deferredMcpToolNames);
@@ -660,11 +672,7 @@ function reconcileDeferredMcpToolCatalogUncached(session, liveMcpTools) {
   const knownBefore = isToolBridgeEnabled(session)
     ? new Map(deferredCatalogUnion(session).map((tool) => [clean(tool?.name), tool]))
     : null;
-  const active = new Set([
-    ...(session.tools || []).map((tool) => clean(tool?.name)).filter(Boolean),
-    ...parseToolSelection(session.deferredCallableTools),
-    ...parseToolSelection(session.deferredDiscoveredTools),
-  ]);
+  const active = persistentToolSurfaceNames(session);
 
   const liveMcpByName = new Map();
   for (const tool of live) {
@@ -723,6 +731,33 @@ function reconcileDeferredMcpToolCatalogUncached(session, liveMcpTools) {
   return [...added.map((entry) => entry.name), ...removed];
 }
 
+/**
+ * Compaction strips the delta reminder from older user turns and the boot
+ * manifest in the system prompt is not rebuilt, so a late MCP tool announced
+ * before a compaction would stay invisible. Re-arm it, exactly as compaction
+ * re-marks the Goal reminder (markPendingGoalReminder): every currently
+ * connected tool the boot manifest never listed and the session has not loaded
+ * or discovered rides the next real prompt as one more delta, acknowledged
+ * only once the provider accepts that turn.
+ * Returns the re-armed names, or null when there are none.
+ */
+export function rearmLateDeferredTools(session) {
+  if (!session || !Array.isArray(session.tools) || fixedSurfaceSession(session)) return null;
+  if (!Array.isArray(session.deferredMcpToolNames) || !Array.isArray(session.deferredAnnouncedTools)) return null;
+  // Listed in the boot manifest, or already loaded/discovered: still visible.
+  const listed = new Set([...session.deferredAnnouncedTools, ...persistentToolSurfaceNames(session)]);
+  const connected = new Set(session.deferredMcpToolNames);
+  const added = [];
+  for (const tool of Array.isArray(session.deferredLateToolCatalog) ? session.deferredLateToolCatalog : []) {
+    const name = clean(tool?.name);
+    if (!name || !connected.has(name) || listed.has(name) || !rosterPermits(session, tool)) continue;
+    added.push({ name, description: lateAnnouncementDescription(tool?.description) });
+  }
+  if (!added.length) return null;
+  mergePendingDeferredToolDelta(session, { added });
+  return added.map((entry) => entry.name);
+}
+
 export function scopedMcpToolsFor(session, config = null) {
   return filterMcpToolsForSession(getMcpTools(session?.mcpScopeId), session?.cwd || null, config);
 }

package/src/runtime/agent/orchestrator/runtime-core/tool-defs.mjs

@@ -73,9 +73,9 @@ export const SESSION_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  trigger: 'Session lookup/control, bot status, agent task sessions, title, compact, fork, Project and worktrees.',
+  trigger: 'Session lookup/control, bot status, agent task sessions and their initial location, title, compact, fork, Project.',
   description:
-    'Inspect sessions or control another by exact ID, never a guessed one. send acknowledges queue intake, not completion: promise a report of it only when its result has reportsBack: true. create returns status: started — started, not done yet; it reports its final answer, after the agents it started finish, unless its result says reportsBack: false. reportsBack: false carries reportsBackReason, the reason to tell the user. Cancel/delete and worktree actions require the user’s request. Other actions affect only the current session. Pass files on with attachments; a reported turn returns the files it produced as attachments.',
+    'Inspect sessions or control another by exact ID, never a guessed one. send acknowledges queue intake, not completion: promise a report of it only when its result has reportsBack: true. create returns status: started — started, not done yet; it reports its final answer, after the agents it started finish, unless its result says reportsBack: false. reportsBack: false carries reportsBackReason, the reason to tell the user. Cancel/delete require the user’s request. Other actions affect only the current session. A new session’s initial location (Project folder branch or its own worktree) is set here, with create’s worktree; worktree operations on existing sessions (enter, return, merge, remove, list, prune) use the git tool’s action:"worktree". Pass files on with attachments; a reported turn returns the files it produced as attachments.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -97,13 +97,9 @@ export const SESSION_TOOL = {
           'list-projects',
           'favorite',
           'archive',
-          'merge-worktree',
-          'remove-worktree',
-          'list-worktrees',
-          'prune-worktrees',
         ],
         description:
-          'status defaults to current; list pages sessions; bots shows each bot’s activity, work, approvals, routines and attention flags, or with session_id (a bot id or its chat) its routines and recent sessions; read returns latest items; send queues prompt (reportsBack: the turn result reports back here); cancel stops the turn; delete removes the session. create (bot conversations) starts a visible agent task session from brief (started, not done yet); unknown Project: list-projects first, still ambiguous: ask the user. compact runs after this turn; fork copies it without switching. merge-worktree merges into the Project’s checked-out branch; remove-worktree returns to the Project (repeat on WORKTREE_REMOVAL_INCOMPLETE); list-worktrees includes retaining sessions; prune-worktrees removes only clean, merged, unretained worktrees.',
+          'status defaults to current; list pages sessions, without sub-agent or archived ones unless include_agents/include_archived; bots shows each bot’s activity, work, approvals, routines and attention flags, or with session_id (a bot id or its chat) its routines and recent sessions; read returns latest items; send queues prompt (reportsBack: the turn result reports back here); cancel stops the turn; delete removes the session. create (bot conversations) starts a visible agent task session from brief (started, not done yet); unknown Project: list-projects first, still ambiguous: ask the user. compact runs after this turn; fork copies it without switching.',
       },
       title: { type: 'string', description: 'rename: new current-session title; create: task title.' },
       session_id: {
@@ -112,6 +108,11 @@ export const SESSION_TOOL = {
           'ID from list; required for read/send/cancel/delete, optional for status/bots. send/cancel/delete cannot target the caller.',
       },
       prompt: { type: 'string', description: 'send: message to enqueue; loads a cold session.' },
+      to: {
+        type: 'string',
+        description:
+          'send to a group room (sess_room_*): the member bot it is for, by agent id or room name (or start prompt with @name); only that member answers. A member session (sess_rmem_*) is never a send target.',
+      },
       limit: {
         type: 'integer',
         minimum: 1,
@@ -120,6 +121,14 @@ export const SESSION_TOOL = {
           'list/read: maximum rows, default 25; bots: sessions, default 10. Output: 8KiB per page, 12KiB for initial read tail; follow nextOffset/nextTextOffset for more.',
       },
       cursor: { type: 'string', description: 'list: returned nextCursor.' },
+      include_agents: {
+        type: 'boolean',
+        description: 'list: also sub-agent sessions, default false; your own agents: agent list/status.',
+      },
+      include_archived: {
+        type: 'boolean',
+        description: 'list: also archived sessions (archived: true), default false.',
+      },
       offset: {
         type: 'integer',
         minimum: 0,
@@ -141,13 +150,25 @@ export const SESSION_TOOL = {
           'Existing directory; implies set-project. Resolve names with list-projects first. Shell cd does not switch Project.',
       },
       compact: { type: 'boolean', description: 'fork: compact the copy.' },
-      force: {
-        type: 'boolean',
-        description: 'remove-worktree: allow uncommitted/unmerged work only when explicitly requested.',
-      },
       value: { type: 'boolean', description: 'favorite/archive: on or off.' },
       brief: { type: 'string', description: 'create: self-contained instruction, the first message.' },
       project: { type: 'string', description: 'create: registered Project name or existing directory.' },
+      worktree: {
+        type: 'object',
+        description:
+          'create: where the new session starts, never carrying uncommitted changes. {mode:"branch"}: the Project folder on its current branch. {mode:"worktree", name?}: its own new managed worktree (name: letters, digits, ".", "_", "-"; default from the title); a non-git folder or unregistered Project is an error. Omitted: the user’s New task default. The brief is sent only once the session is placed.',
+        properties: {
+          mode: { type: 'string', enum: ['branch', 'worktree'] },
+          name: { type: 'string', maxLength: 64, description: 'mode worktree: worktree name.' },
+        },
+        required: ['mode'],
+        additionalProperties: false,
+      },
+      confirm_large: {
+        type: 'boolean',
+        description:
+          'create: only after the user confirmed the large-repository warning (WORKTREE_LARGE_REPO_CONFIRM, with its size) for the worktree.',
+      },
       model: {
         type: 'string',
         description: 'create: provider/model or preset; default is the Lead model (else the last-used one).',

package/src/runtime/agent/orchestrator/runtime-core/workflow.mjs

@@ -64,10 +64,13 @@ export function toSessionWorkflowMeta(workflow) {
 }
 
 // Older sessions stored delegation policy here. Current summaries retain the
-// effective capability so an empty agent catalog still removes the tool.
-export function workflowDisallowsAgentTool(workflow) {
+// effective capability: an empty agent catalog removes the tool from an
+// agent-mode Lead only. A coding Lead keeps `agent` whichever agents exist;
+// the agents it may delegate to reach it as a listing reminder
+// (manager/agent-listing-notice.mjs) and a spawn of one switched off is refused.
+export function workflowDisallowsAgentTool(workflow, { agentMode = false } = {}) {
   if (!workflow || typeof workflow !== 'object') return false;
-  if (workflow.delegatesAgents === false) return true;
+  if (agentMode && workflow.delegatesAgents === false) return true;
   return Boolean(workflow.agentsConfigured === true && Array.isArray(workflow.agents) && workflow.agents.length === 0);
 }
 

package/src/runtime/agent/orchestrator/session/agent-loop.mjs

@@ -61,7 +61,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // owns a bounded recovery ladder in ./loop/no-tool-turn.mjs, which either
     // appended a recovery turn ('continue') or produced the terminal response.
     if (!state.response.toolCalls?.length) {
-      const outcome = state.noToolTurn.resolve(state.response, state.iterations);
+      const outcome = await state.noToolTurn.resolve(state.response, state.iterations);
       state.response = outcome.response;
       if (outcome.action === 'continue') continue;
       break;

package/src/runtime/agent/orchestrator/session/agent-room.d.mts

@@ -9,6 +9,11 @@ export interface RoomRow {
   to?: string[] | string;
   toName?: string[] | string;
   failed?: boolean;
+  /** A user-kind row another session sent: its session, the sending bot
+   *  (none for the user's Lead) and the name it is shown under. */
+  fromSession?: string;
+  fromAgent?: string;
+  fromName?: string;
   limit?: 'rounds' | 'messages';
   rounds?: number;
   messages?: number;
@@ -93,6 +98,7 @@ export function parseRoomAsk(
   text: unknown,
   members?: readonly RoomMemberLabel[]
 ): { to: string[]; text: string; error?: 'member' | 'message' };
+export function roomMemberNamed(value: unknown, members?: readonly RoomMemberLabel[]): string;
 export function roomMentionOf(text: unknown, members?: readonly RoomMemberLabel[], selfId?: string): string;
 export function roomRowTargets(row?: Partial<RoomRow>): RoomMemberLabel[];
 export function isPassReply(text: unknown): boolean;
@@ -139,6 +145,8 @@ export function runRoomExchange(options: {
   /** The user's newest message has no answer yet (default true): until a
    *  member speaks, a step must pick. */
   waiting?: boolean;
+  /** The called members (`to`) answer and nobody else follows. */
+  only?: boolean;
 }): Promise<RoomExchangeResult>;
 export function roomDataLabel(value: unknown): string;
 export function roomDataLines(text: unknown): string[];
@@ -165,6 +173,10 @@ export function roomTurnPrompt(options: {
   scene?: RoomScene;
   /** The user's newest message still has no answer (default: it is the newest row). */
   waiting?: boolean;
+  /** The sender of the message this member was asked from another session. */
+  askedBy?: string;
+  /** The member's own reported work it relays to the room this turn. */
+  relay?: string;
 }): string | RoomPromptPart[];
 export function normalizeRoomRow(row?: Partial<RoomRow> & Record<string, unknown>): RoomRow;
 export function roomRowMessage(row: Partial<RoomRow>): {
@@ -179,3 +191,4 @@ export function roomRowMessage(row: Partial<RoomRow>): {
 export function isRoomRowMessage(message: unknown): boolean;
 export function roomRowItem(message: unknown, id?: unknown): Record<string, unknown>;
 export function roomRowsOfItems(items: unknown): RoomRow[];
+export function roomRowSender(room: unknown): { fromAgent?: string; sender?: 'lead' };

package/src/runtime/agent/orchestrator/session/agent-room.mjs

@@ -12,6 +12,7 @@
 // content to the members the row reaches, once each.
 import { escapeHarnessTags } from '../../../shared/shell-output-summary.mjs';
 import { normalizeMessageAttachments, transcriptAttachmentFields } from '../../../shared/transcript-metadata.mjs';
+import { AGENT_MESSAGE_NOTE } from '../../../shared/agent-message-envelope.mjs';
 import { agentHomeSessionId } from './agent-home.mjs';
 
 const ROOM_PREFIX = 'sess_room_';
@@ -41,6 +42,7 @@ const TOOL_SUMMARY_LIMIT = 400;
 const ATTACHMENT_REF = /^[a-f0-9]{64}$/;
 const PART_TYPES = new Set(['image', 'file', 'text']);
 const ATTACHMENT_LIMIT = 64;
+const SENDER_SESSION = /^[A-Za-z0-9_.:-]{1,200}$/;
 
 export function isRoomId(value) {
   return typeof value === 'string' && ROOM_ID.test(value);
@@ -138,6 +140,13 @@ function memberAt(text, members, boundary) {
   return tie ? null : best;
 }
 
+/** The member `value` names exactly (its id or display name, any case); ''
+ *  for none, or a name two members share. */
+export function roomMemberNamed(value, members = []) {
+  const text = String(value ?? '').trim();
+  return (text && memberAt(text, members, /(?!)/)?.id) || '';
+}
+
 /** A user message to the room: `/ask <agent>[, <agent>…] <message>` addresses
  *  those members, in that order, by id or by name. `{ to, text }`, `to` the
  *  ordered member ids ([] for the whole room); `error` is 'member' (no such
@@ -283,7 +292,10 @@ export async function runRoomExchange({
   stopped = () => false,
   superseded = () => false,
   waiting = true,
+  only = false,
 }) {
+  // A room whose last member was removed has nobody to hear it: finished, no turns.
+  if (!members.length) return { outcome: 'done', rounds: 0, steps: 0, messages: 0 };
   const targets = [...new Set((Array.isArray(to) ? to : [to]).filter((id) => members.includes(id)))];
   const maxSteps = maxRounds * members.length;
   const turns = [];
@@ -337,6 +349,9 @@ export async function runRoomExchange({
   };
   const answered = await callEach(targets);
   if (answered) return answered;
+  // `only`: the called members answer and nobody else follows (a message
+  // from another session, a member relaying its own work).
+  if (only && targets.length) return end('done');
   for (;;) {
     let halt = halted();
     if (halt) return halt;
@@ -456,8 +471,14 @@ export function roomTurnPrompt({
   instruction = '',
   scene = 'work',
   waiting = rows.at(-1)?.kind === 'user' && !rows.at(-1)?.seen,
+  askedBy = '',
+  relay = '',
 }) {
   const userLast = rows.at(-1)?.kind === 'user';
+  // A relay of the member's own reported work, or a message that waits for
+  // an answer: no permission to pass.
+  const urged = waiting || Boolean(relay);
+  const asker = askedBy ? label(askedBy) : '';
   const others = members.filter((member) => member.id !== self.id).map((member) => label(member.name));
   // `addressed`: the members the user asked (or true for this member alone).
   const asked = Array.isArray(addressed) ? addressed.length > 0 : addressed === true;
@@ -465,11 +486,15 @@ export function roomTurnPrompt({
   const note = String(instruction ?? '').trim() ? label(instruction).slice(0, ROOM_INSTRUCTION_LIMIT) : '';
   const lines = [
     `[mixdog-runtime] Group room "${label(roomName)}". You are ${label(self.name)}; the other members are ${others.join(', ')}. The user and the members share this one room and members speak one at a time.`,
-    askedWith
-      ? 'The user asked you and other named members directly: only those members answer this time, one at a time.'
-      : asked
-        ? 'The user asked you directly: only you answer this time.'
-        : 'It is your turn.',
+    relay
+      ? 'Results of work you started yourself (sessions you created or sent to) arrived; they follow the room lines below. Relay them to the room now, briefly and in your own words: only you speak this time.'
+      : askedWith
+        ? 'The user asked you and other named members directly: only those members answer this time, one at a time.'
+        : asked
+          ? asker
+            ? `${asker} asked you directly from another session: only you answer this time.`
+            : 'The user asked you directly: only you answer this time.'
+          : 'It is your turn.',
     ...(asked
       ? [
           'When the user wants another member involved, whatever name they use, write that member as @Name in your reply so the room can hand them a turn.',
@@ -491,9 +516,11 @@ export function roomTurnPrompt({
     // so a message to the room never meets silence.
     ...(waiting
       ? [
-          userLast
-            ? 'The user just spoke and nobody has answered yet: reply to the user now, in their language. Do not pass.'
-            : "Nobody has answered the user's newest message yet (the member messages after it were written before it arrived): reply to that message now, in the user's language. Do not pass.",
+          asker
+            ? `${asker}'s message has no answer yet: reply to it now. Do not pass.`
+            : userLast
+              ? 'The user just spoke and nobody has answered yet: reply to the user now, in their language. Do not pass.'
+              : "Nobody has answered the user's newest message yet (the member messages after it were written before it arrived): reply to that message now, in the user's language. Do not pass.",
         ]
       : []),
     ...(scene === 'casual'
@@ -506,13 +533,13 @@ export function roomTurnPrompt({
               ]),
           'Do not offer help or ask what the user needs unless they asked for help, and do not summarise the room or speak for the others.',
           'Speak from your own role and the work you remember; never invent facts the user could rely on.',
-          waiting
+          urged
             ? 'Never say you have nothing to add or nothing to report; say something in character instead.'
             : `Never say you have nothing to add or nothing to report; when you truly have nothing to say, reply exactly "${ROOM_PASS_REPLY}".`,
           'Do not end every message with a question.',
         ]
       : [
-          ...(waiting
+          ...(urged
             ? []
             : [
                 `Reply with your message to the room as plain text. Speak only to answer an open question, add relevant evidence, name a concrete disagreement or propose a useful next step; otherwise reply exactly "${ROOM_PASS_REPLY}".`,
@@ -527,7 +554,7 @@ export function roomTurnPrompt({
   ];
   if (!rows.some((row) => !row.seen)) {
     lines.push('Nothing new was said since your last turn.');
-    if (!waiting) {
+    if (!urged) {
       lines.push(
         `This is not a direct call: speak only for what the lines above ask of you; otherwise reply exactly "${ROOM_PASS_REPLY}".`
       );
@@ -578,12 +605,24 @@ export function roomTurnPrompt({
         : rest.length
           ? `to you and ${rest.join(', ')} only`
           : 'to you only';
-    lines.push(`The user${row.seen ? ' (earlier, already shown to you)' : ''}, ${target}:`, String(row.text ?? ''));
+    // A message another session sent into the room names its real sender: a
+    // bot's words carry the trust note of every bot-to-bot message.
+    const who = row.fromName
+      ? `${label(row.fromName)} (${row.fromAgent ? 'another bot' : "the user's Lead"}, from another session, not the user)`
+      : 'The user';
+    lines.push(
+      `${who}${row.seen ? ' (earlier, already shown to you)' : ''}, ${target}:`,
+      ...(row.fromAgent ? [AGENT_MESSAGE_NOTE] : []),
+      String(row.text ?? '')
+    );
     // The user's files follow their words, for the members the message reaches.
     const files = !row.seen && (rest.length < targets.length || !targets.length) ? storedParts(row.parts) : [];
     if (files.length) content.push({ type: 'text', text: lines.splice(0).join('\n') }, ...files);
   }
   if (open) lines.push('</room-transcript>');
+  // The member's reported work (agentTaskWakePrompt: runtime text, task
+  // output already escaped inside its own boundary).
+  if (relay) lines.push(String(relay));
   if (!content.length) return lines.join('\n');
   return lines.length ? [...content, { type: 'text', text: lines.join('\n') }] : content;
 }
@@ -653,12 +692,19 @@ export function normalizeRoomRow(row = {}) {
   const parts = carriesFiles ? storedParts(row.parts) : [];
   const attachments = carriesFiles ? normalizeMessageAttachments(row.attachments) : [];
   const images = row.kind === 'user' ? storedImages(row.images) : [];
+  // A user-kind row another session sent (session send to the room): its
+  // sender session, the sending bot (none for the user's Lead) and its name.
+  const fromSession =
+    row.kind === 'user' && typeof row.fromSession === 'string' && SENDER_SESSION.test(row.fromSession)
+      ? row.fromSession
+      : '';
   return {
     id,
     kind: row.kind,
     ...(Number.isFinite(row.at) ? { at: row.at } : {}),
     ...named('speaker'),
     ...named('name'),
+    ...(fromSession ? { fromSession, ...named('fromAgent'), fromName: cleanName(row.fromName) || 'Lead' } : {}),
     ...(targets.length
       ? { to: targets.map((target) => target.id), toName: targets.map((target) => target.name || target.id) }
       : {}),
@@ -730,9 +776,19 @@ export function roomRowItem(message, id) {
     // A user row's (or member speech's) files, in the fields a chat prompt's row draws them from.
     ...(room.kind === 'user' || room.kind === 'speech' ? transcriptAttachmentFields(message.meta.transcript) : {}),
     ...(room.kind === 'user' && Array.isArray(images) && images.length ? { images } : {}),
+    ...roomRowSender(room),
   };
 }
 
+/** The attribution a user-kind room row from another session shows on its
+ *  bubble, in the fields a chat prompt row has: the sending bot
+ *  (`fromAgent`), else the user's Lead (`sender: 'lead'`); none for the
+ *  user's own message. */
+export function roomRowSender(room) {
+  if (room?.kind !== 'user' || !room.fromSession) return {};
+  return room.fromAgent ? { fromAgent: room.fromAgent } : { sender: 'lead' };
+}
+
 /** The room rows of a transcript (`{ room }` items) as row descriptors, in order. */
 export function roomRowsOfItems(items) {
   const rows = [];

package/src/runtime/agent/orchestrator/session/compact/continuation.mjs

@@ -1,4 +1,8 @@
-import { isProtectedContextAckMessage, latestActualUserInstructionIndex } from './messages.mjs';
+import {
+  isProtectedContextAckMessage,
+  latestActualUserInstructionIndex,
+  pendingTaskNotificationIndexes,
+} from './messages.mjs';
 
 export const ACTIVE_TURN_CONTINUATION_SOURCE = 'compact-active-turn-continuation';
 export const ACTIVE_TURN_CONTINUATION_ANCHOR = '<active-turn-continuation>';
@@ -22,7 +26,7 @@ function makeActiveTurnContinuationMessage() {
     content: [
       '<system-reminder>',
       ACTIVE_TURN_CONTINUATION_ANCHOR,
-      'The latest real user request was already in progress when Compact ran.',
+      'The latest real user request or task notification was already in progress when Compact ran.',
       'The handoff and retained execution records above describe progress so far. A plan is not evidence that a tool succeeded; use the recorded outcomes.',
       'Continue from that state without repeating progress messages or completed tool calls.',
       'Use tools only for incomplete or failed work, or to recover missing evidence from an execution archive.',
@@ -38,10 +42,15 @@ function makeActiveTurnContinuationMessage() {
 
 export function activeTurnContinuationMessage(messages) {
   const list = Array.isArray(messages) ? messages : [];
-  const latestUserIndex = latestActualUserInstructionIndex(list);
-  if (latestUserIndex < 0) return null;
-  const afterLatestUser = list.slice(latestUserIndex + 1);
-  if (!afterLatestUser.some(isExistingContinuation) && !afterLatestUser.some(isExecutionActivity)) {
+  // The turn's latest input: a real user request or an unanswered task
+  // notification. Only execution after it is progress of the current turn.
+  const latestInputIndex = Math.max(
+    latestActualUserInstructionIndex(list),
+    pendingTaskNotificationIndexes(list).at(-1) ?? -1
+  );
+  if (latestInputIndex < 0) return null;
+  const afterLatestInput = list.slice(latestInputIndex + 1);
+  if (!afterLatestInput.some(isExistingContinuation) && !afterLatestInput.some(isExecutionActivity)) {
     return null;
   }
   return makeActiveTurnContinuationMessage();