mixdog 1.2.6 → 1.3.1

package/src/runtime/agent/orchestrator/session/manager/session-crud.mjs

@@ -28,6 +28,7 @@ import { mintSessionId } from './session-id.mjs';
 import { hideCompactionArchive } from '../compaction-archive-capture.mjs';
 import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { forgetSideQuestion } from '../side-question-store.mjs';
+import { isAgentHomeSessionId } from '../agent-home.mjs';
 
 /** Force-flush session metrics to disk. */
 export async function flushSessionMetrics(sessionId) {
@@ -207,9 +208,12 @@ function clearTokenAccounting(session, messages, keep, beforeMessageTokens) {
 // Fork the outgoing transcript to a separate resumable session BEFORE the wipe,
 // so the conversation about to be discarded stays reachable via /resume under a
 // fresh id. Best-effort: any failure here must never block the clear itself.
-function forkOutgoingTranscript(session, messages, now) {
+// `archiveAs` names the fork (an agent home's "대화 새로 시작": the host
+// archives that id before the clear) and makes it durable first: the returned
+// promise settles once the copy is on disk, and the wipe waits on it.
+function forkOutgoingTranscript(session, messages, now, archiveAs = '') {
   try {
-    const forkId = mintSessionId();
+    const forkId = archiveAs || mintSessionId();
     const fork = {
       ...session,
       id: forkId,
@@ -234,6 +238,15 @@ function forkOutgoingTranscript(session, messages, now) {
       delete fork.compaction.archive;
     }
     setLiveSession(fork);
+    if (archiveAs) {
+      return saveSessionAsync(fork).then(
+        () => evictLiveSession(forkId),
+        (err) => {
+          evictLiveSession(forkId);
+          throw err;
+        }
+      );
+    }
     void saveSessionAsync(fork)
       .then(() => {
         // The fork is a cold snapshot kept for /resume. Once durable on
@@ -247,17 +260,33 @@ function forkOutgoingTranscript(session, messages, now) {
         writeStderrBestEffort(`[session] clear-fork save failed (sess=${forkId}): ${err?.message || err}\n`);
       });
   } catch (err) {
+    if (archiveAs) throw err;
     writeStderrBestEffort(`[session] clear-fork failed (sess=${session.id}): ${err?.message || err}\n`);
   }
 }
 
+const ARCHIVE_ID = /^sess_[A-Za-z0-9_-]{8,200}$/;
+
+/** The fork id a clear was asked to archive under, '' when none. */
+function clearArchiveId(value, sessionId) {
+  if (value === undefined || value === null || value === '') return '';
+  const id = String(value);
+  if (!ARCHIVE_ID.test(id) || id === sessionId || isAgentHomeSessionId(id)) {
+    throw new Error('clear: archiveAs must be a fresh session id');
+  }
+  if (loadSession(id)) throw new Error(`clear: session ${id} already exists`);
+  return id;
+}
+
 export async function clearSessionMessages(sessionId, options = {}) {
   const session = loadSession(sessionId);
   if (!session) return false;
   // Don't resurrect a closed session just to clear its messages.
   if (session.closed === true) return false;
   const clearOptions = options && typeof options === 'object' ? options : {};
-  const compact = clearOptions.compact === true;
+  const archiveAs = clearArchiveId(clearOptions.archiveAs, sessionId);
+  // An archived reset keeps the whole transcript: never compacted first.
+  const compact = clearOptions.compact === true && !archiveAs;
   const currentMessages = Array.isArray(session.messages) ? session.messages : [];
   const beforeMessageTokens = estimateMessagesTokens(currentMessages);
   const { messages, clearCompactError } = compact
@@ -275,8 +304,14 @@ export async function clearSessionMessages(sessionId, options = {}) {
   // content the live session retains via the summary, so the fork duplicated
   // it as a confusing extra Recent row ("Re-attached after compaction…" —
   // user report). Plain /clear (no summary kept) still forks.
+  // `fork: false` (a room member's reset: the room's own log keeps the
+  // conversation) skips the copy; an `archiveAs` clear always keeps one.
   const summaryCarriedForward = keep.some(isCompactSummaryMessage);
-  if (hasUserConversationMessage(messages) && !summaryCarriedForward) forkOutgoingTranscript(session, messages, now);
+  const keepCopy = clearOptions.fork !== false || Boolean(archiveAs);
+  if (keepCopy && hasUserConversationMessage(messages) && !summaryCarriedForward) {
+    const fork = forkOutgoingTranscript(session, messages, now, archiveAs);
+    if (archiveAs) await fork;
+  }
 
   session.messages = keep;
   // Clear truncates the transcript wholesale; drop the provider prefix

package/src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs

@@ -9,6 +9,7 @@ import { saveSession, saveSessionAsync, saveSessionAsyncDeferred, loadSession, s
 import { _liveSessions } from '../store/live-state.mjs';
 import { _recoverTurnCheckpointDurably } from './turn-checkpoint-recovery.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
+import { AGENT_MODE, resolveSessionMode, sessionModeOf } from '../agent-mode.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
 import {
@@ -18,7 +19,9 @@ import {
 } from '../../agent-runtime/cache-strategy.mjs';
 import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
 import { _buildBaseRules } from './rules-cache.mjs';
+import { stripProviderReplayMessages } from './provider-replay.mjs';
 import { composeSessionSystem, seedSessionMessages } from './session-prompt-composition.mjs';
+import { agentProfileRevision, leadRosterRevision } from '../../context/role-instructions.mjs';
 import {
   _prepareResumeTools,
   delegationDisabled,
@@ -206,12 +209,22 @@ function logSessionSurface({ resolvedAgent, toolPermission, tools }) {
   }
 }
 
-export function createSession(opts) {
-  const presetObj = opts.preset && typeof opts.preset === 'object' ? opts.preset : null;
-  const resolved = resolveAgentRuntimeProfile(opts, presetObj);
+export function createSession(createOpts) {
+  const presetObj = createOpts.preset && typeof createOpts.preset === 'object' ? createOpts.preset : null;
+  const resolved = resolveAgentRuntimeProfile(createOpts, presetObj);
   const { profile } = resolved;
-  const route = resolveSessionRoute(opts, presetObj, profile);
+  const route = resolveSessionRoute(createOpts, presetObj, profile);
   const { providerName, modelName, provider, toolPreset, id } = route;
+  // Agent or coding mode (agent-mode.mjs), resolved once and persisted. An
+  // agent-mode Lead acts as its agent: a schedule/webhook run that names only
+  // its `ownerAgentId` gets that agent's role, persona and connector policy
+  // (all keyed by `session.agent`), as its home thread does.
+  const sessionMode = sessionModeOf({ ...createOpts, id });
+  const actingAgent = resolveSessionMode({ session: { ...createOpts, id } }).agentId;
+  const opts =
+    sessionMode === AGENT_MODE && !createOpts.agent && actingAgent
+      ? { ...createOpts, agent: actingAgent, sessionMode }
+      : { ...createOpts, sessionMode };
   const routeFallbacks = normalizeWorkflowRoute({
     provider: providerName,
     model: modelName,
@@ -227,7 +240,12 @@ export function createSession(opts) {
   // Scoped to explicit-breakpoint (Anthropic-family) providers only.
   const providerCacheOpts = resolved.providerCacheOpts || buildSessionProviderCacheOpts(providerName, id, opts.agent);
   const surface = resolveSessionToolSurface(opts, { profile, toolPreset, modelName });
-  const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface });
+  // The agent profile the prompt is composed from, read first: an edit landing
+  // during composition leaves the stamp behind, never ahead (refreshAgentProfile).
+  const agentProfile = surface.ownerIsAgent
+    ? ''
+    : agentProfileRevision(surface.resolvedAgent, { mixy: sessionMode === AGENT_MODE });
+  const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode });
   const messages = seedSessionMessages(prompt, opts.files);
   logSessionSurface(surface);
   const contextMeta = resolveSessionContextMeta(provider, modelName, {
@@ -246,6 +264,11 @@ export function createSession(opts) {
     origin: sessionOriginFields(opts, { profile, presetObj, providerCacheOpts, surface }),
   });
   session.providerCacheOptsOverride = Boolean(resolved.providerCacheOpts);
+  if (agentProfile) {
+    session.agentProfileRevision = agentProfile;
+    // The bot roster its prompt lists (a Lead's catalog slices).
+    session.agentRosterRevision = leadRosterRevision(opts.leadWorkflowParts);
+  }
   if (routeFallbacks?.length) session.routeFallbacks = routeFallbacks;
   // A non-native agent sends core + bridge, built from its filtered tools.
   applyAgentToolExposure(session);
@@ -401,27 +424,11 @@ function resetSessionForRouteChange(id, session, previousModel, previousProvider
   _forgetPreparedResume(id);
 }
 
-// Every message field a provider adapter replays or re-reads as native state.
-const PROVIDER_REPLAY_FIELDS = [
-  'providerReplay',
-  'reasoning',
-  'thinkingBlocks',
-  'assistantBlocks',
-  'reasoningItems',
-  'reasoningContent',
-  'providerMetadata',
-];
-
-// Provider-native replay (reasoning items, thinking blocks) belongs to the
-// provider that produced it. Replace, never mutate, so delta saves rewrite.
+// Provider-native replay (reasoning items, thinking blocks, signatures)
+// belongs to the provider that produced it (see provider-replay.mjs).
 function stripProviderReplay(session) {
   if (!Array.isArray(session.messages)) return;
-  session.messages = session.messages.map((message) => {
-    if (!message || !PROVIDER_REPLAY_FIELDS.some((field) => field in message)) return message;
-    const plain = { ...message };
-    for (const field of PROVIDER_REPLAY_FIELDS) delete plain[field];
-    return plain;
-  });
+  session.messages = stripProviderReplayMessages(session.messages);
 }
 
 // `options.crossProvider` is the explicit in-place continuation of an
@@ -532,6 +539,8 @@ export async function resumeSession(sessionId, preset, options = {}) {
   ensureCodexWireSessionId(session);
   if (!_applyDesktopResumeScope(session, options)) return null;
   if (!session.owner) session.owner = 'user';
+  // Records from before the mode existed get it resolved and stamped.
+  session.sessionMode = sessionModeOf(session);
   if (Object.hasOwn(options, 'mcpScopeId')) {
     session.mcpScopeId = String(options.mcpScopeId || '').trim() || null;
   }

package/src/runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs

@@ -4,9 +4,13 @@
 // carry all four to the provider with their cache tiers.
 import { buildSkillManifest, composeSystemPrompt } from '../../context/collect.mjs';
 import { configuredInstructionFilesMode, loadInstructionFilesContext } from '../../context/instruction-files.mjs';
+import { agentModeIdentityLine } from '../../context/role-instructions.mjs';
+import { AGENT_MODE, isRoutineSource, sessionModeOf } from '../agent-mode.mjs';
+import { MIXY_AGENT_ID } from '../agent-home.mjs';
 import {
   _buildBaseRules,
   _buildAgentRules,
+  _buildAgentModeRules,
   _buildLeadRules,
   _buildLeadMetaContext,
   _buildLeadLanguageContext,
@@ -81,8 +85,9 @@ export function buildWorkspacePromptContext(session, cwd) {
   ];
   return {
     environmentContext: buildShellEnvironmentContext({ cwd }, ownerIsAgent, tools),
+    // Agent mode never carries project instruction files.
     instructionFilesContext:
-      session?.skipInstructionFiles === true
+      session?.skipInstructionFiles === true || sessionModeOf(session) === AGENT_MODE
         ? undefined
         : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd }),
   };
@@ -90,24 +95,60 @@ export function buildWorkspacePromptContext(session, cwd) {
 
 // BP1/BP2/BP3 rule blocks plus the volatile environment, composed into the
 // four system blocks; environmentTailContext is the persisted env tail.
-export function sessionRolePromptFields(identity, { ownerIsAgent, toolFreeRole, delegationFree }) {
+// A Lead's BP3 rule slices, ordered for prefix sharing (composeSystemPrompt):
+// LEAD.md's common lines first; then the mode block (coding: LEAD.md's two
+// passages; agent mode: their conversational variants and AGENT_MODE.md);
+// then Mixy's MIXY.md; last the per-session tail — routine line, identity.
+// Agent mode is a Lead created as an agent (agent-mode.mjs).
+export function sessionRolePromptFields(
+  identity,
+  { ownerIsAgent, toolFreeRole, delegationFree, sessionMode, routine = false }
+) {
   const skipRules = identity.skipAgentRules || toolFreeRole;
+  const lead = !ownerIsAgent && !skipRules;
+  const agentMode = lead && sessionMode === AGENT_MODE;
+  const mixy = (identity.agent || MIXY_AGENT_ID) === MIXY_AGENT_ID;
   let roleRules = '';
   if (!skipRules) {
     roleRules = ownerIsAgent
       ? _buildAgentRules(identity.agentRulesProfile)
       : _buildLeadRules({ includeLeadBrief: !delegationFree });
   }
+  const identityLine = agentMode
+    ? agentModeIdentityLine(identity.agent || MIXY_AGENT_ID)
+    : lead
+      ? _buildLeadRules({ includeLeadBrief: !delegationFree, part: 'identity' })
+      : '';
   return {
     roleRules,
+    ...(lead
+      ? {
+          leadModeRules: _buildLeadRules({ includeLeadBrief: !delegationFree, part: agentMode ? 'agent' : 'coding' }),
+          identityContext: identityLine ? `# Identity\n\n${identityLine}` : '',
+        }
+      : {}),
+    ...(agentMode
+      ? {
+          agentModeRules: _buildAgentModeRules({ part: 'conduct' }),
+          ...(mixy ? { mixyRules: _buildAgentModeRules({ part: 'mixy' }) } : {}),
+          ...(routine ? { routineRules: _buildAgentModeRules({ part: 'routine' }) } : {}),
+        }
+      : {}),
     userPrompt: identity.systemPrompt,
-    skipRoleCatalog: !ownerIsAgent,
+    // A coding Lead carries no role section; an agent's home thread (a user
+    // session running as that agent) carries its own AGENT.md role, and Mixy
+    // in agent mode its optional agents/lead/AGENT.md.
+    skipRoleCatalog: !ownerIsAgent && (!identity.agent || identity.agent === 'lead') && !(agentMode && mixy),
+    // Mixy's persona (bots/mixy/PERSONA.md) is Mixy's alone: keyed on Mixy's
+    // own agent-mode thread, never on the `lead` role a coding Lead shares.
+    skipPersona: !ownerIsAgent && (!identity.agent || identity.agent === 'lead') && !(agentMode && mixy),
     agent: identity.agent,
     profile: { skip: identity.profileSkip },
   };
 }
 
-export function composeSessionSystem(opts, { profile, providerName, modelName, surface }) {
+export function composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode }) {
+  const agentMode = sessionMode === AGENT_MODE;
   const { ownerIsAgent, resolvedAgent, skills } = surface;
   // A tool-free hidden role (a one-shot classifier or title writer) carries
   // only its own role rules: the shared tool policy and the worker conduct
@@ -130,9 +171,15 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     agent: resolvedAgent,
     agentRulesProfile: surface.agentRulesProfile,
   };
-  const roleFields = sessionRolePromptFields(promptIdentity, { ownerIsAgent, toolFreeRole, delegationFree });
+  const roleFields = sessionRolePromptFields(promptIdentity, {
+    ownerIsAgent,
+    toolFreeRole,
+    delegationFree,
+    sessionMode,
+    routine: isRoutineSource(opts.sourceType),
+  });
   const leadOnly = !skipAgentRules && !ownerIsAgent;
-  const metaContext = leadOnly ? _buildLeadMetaContext() : '';
+  const metaContext = leadOnly ? _buildLeadMetaContext({ includeOutputStyle: !agentMode }) : '';
   // Lead-only response language; closes the environment block so no English
   // system text (session/shell/git lines) follows it.
   const languageContext = leadOnly ? _buildLeadLanguageContext() : '';
@@ -146,9 +193,10 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
   // already sit at the end of this string to stay last after a refresh.
   const environmentTailContext = [shellEnvironmentContext, languageContext].filter(Boolean).join('\n\n---\n\n');
   // User instruction files (AGENTS.md / CLAUDE.md, global then the project
-  // root's); a tool-free role and a profile skipping `claudemd` get none.
+  // root's); a tool-free role, a profile skipping `claudemd` and agent mode
+  // get none.
   const instructionFilesContext =
-    toolFreeRole || profile?.skip?.claudemd
+    toolFreeRole || profile?.skip?.claudemd || agentMode
       ? ''
       : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd: opts.cwd });
   const composed = composeSystemPrompt({
@@ -157,6 +205,8 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     metaContext: metaContext || undefined,
     languageContext: languageContext || undefined,
     workflowContext: opts.workflowContext || null,
+    // The workflow's orchestration and agent-catalog slices (workflow/context.mjs leadPromptParts).
+    ...(ownerIsAgent ? {} : opts.leadWorkflowParts),
     coreMemoryContext: opts.coreMemoryContext || null,
     instructionFilesContext: instructionFilesContext || null,
     skillManifest: buildSkillManifest(skills),

package/src/runtime/agent/orchestrator/session/manager/session-record.mjs

@@ -70,6 +70,20 @@ export function sessionOriginFields(opts, { profile, presetObj, providerCacheOpt
     // scheduler/daily-standup, webhook/github-push, lead/worker.
     sourceType: opts.sourceType || null,
     sourceName: opts.sourceName || null,
+    // The agent a schedule/webhook run acts for: whose memory it may write
+    // (session-runtime/services/memory-access.mjs). Absent on other sessions.
+    ...(opts.ownerAgentId ? { ownerAgentId: String(opts.ownerAgentId) } : {}),
+    // A coding task session an agent created (session create): who asked, from
+    // which thread, the request, and the title it was given.
+    ...(opts.taskOrigin
+      ? {
+          taskOrigin: opts.taskOrigin,
+          title: opts.taskOrigin.title,
+          titleLocked: true,
+          titleSource: 'ai',
+          titleUpdatedAt: Date.now(),
+        }
+      : {}),
     // Provider-scoped unified cache key — one shard per provider,
     // shared across all roles / sources (agent/maintenance/mcp/
     // scheduler/webhook). Role or source-specific context must be
@@ -137,6 +151,8 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     selectedContextWindow: opts.selectedContextWindow || null,
     agent: opts.agent,
     owner: opts.owner || 'user',
+    // 'agent' | 'coding' (session/agent-mode.mjs), resolved at creation.
+    sessionMode: opts.sessionMode,
     bp3CoreContext: prompt.sessionMarkerCore,
     promptIdentity: prompt.promptIdentity,
     callerDisallowedTools: [...(opts.callerDisallowedTools ?? opts.disallowedTools ?? [])],

package/src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs

@@ -22,8 +22,9 @@ import { ROUTE_TOOL_ORDER } from '../../runtime-core/tool-catalog-data.mjs';
 // the sort overhead on ~30 tools is negligible.
 function _getMcpTools(mcpScopeId = null, cwd = null) {
   // Project scope: servers limited to other project roots stay connected
-  // but leave this session's schema (session-runtime/extension-scopes).
-  const mcp = filterMcpToolsForSession(getMcpTools(mcpScopeId) || [], cwd);
+  // but leave this session's schema (session-runtime/extension-scopes). An
+  // agent's connectors apply at dispatch, never here.
+  const mcp = filterMcpToolsForSession(getMcpTools(mcpScopeId) || [], cwd, null);
   // `public:false` tools stay registered in internal-tools for runtime
   // rewrites/dispatch, but must never enter any model-visible schema (Lead
   // full/mcp included). Filter before mapping because the projection below

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint.mjs

@@ -18,6 +18,7 @@ import {
   writeCheckpointHeader,
 } from './turn-checkpoint-journal.mjs';
 import { captureTurnCheckpointContextState, restoreTurnCheckpointContextState } from './turn-checkpoint-context.mjs';
+import { stripProviderReplayMessages } from './provider-replay.mjs';
 
 export { turnCheckpointPath, turnMessagesForCheckpoint };
 export { captureTurnCheckpointContextState, restoreTurnCheckpointContextState };
@@ -198,7 +199,12 @@ export function recoverTurnCheckpoint(session) {
   const current = Array.isArray(session.messages) ? session.messages : [];
   const start = findTurnStart(current, checkpoint.currentUserContent);
   const kept = start >= 0 ? current.slice(0, start) : current;
-  session.messages = checkpoint.fullTranscript === true ? finalized.messages : [...kept, ...finalized.messages];
+  // The route switched models mid-turn (the marker says so) and the journal
+  // may predate the switch: its turn still carries the previous provider's
+  // native replay state, which the saved route's provider must not receive.
+  const turnMessages =
+    marker?.routeChanged === true ? stripProviderReplayMessages(finalized.messages) : finalized.messages;
+  session.messages = checkpoint.fullTranscript === true ? turnMessages : [...kept, ...turnMessages];
   // Re-anchor provider usage / post-compact replacement state to the exact
   // canonical checkpoint representation. If a legacy or corrupted checkpoint
   // cannot prove alignment, retain the last provider reading for display but

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -7,6 +7,7 @@
 // flag usageMetricsTurnIncremental. manager.mjs wires it via configureUsageMetricsRuntime().
 import { providerInputExcludesCache } from '../../providers/registry.mjs';
 import { reasoningUsage, combineReasoningUsage } from '../../../../shared/llm/reasoning-usage.mjs';
+import { foldUsageReadout } from '../../../../shared/usage-readout-totals.mjs';
 import {
   loadSession,
   saveSessionAsync,
@@ -553,6 +554,11 @@ export async function persistIterationMetrics(delta) {
   if (!isReplay) {
     if (runtimeEntry) runtimeEntry.usageMetricsTurnIncremental = true;
     accumulateSessionUsage(session, delta);
+    // The composer readout's session-cumulative cache hit and speed: one fold
+    // per model call of this session (every tool-loop iteration), replaced
+    // immutably so a consumer can tell by identity that it changed. Sessions
+    // saved before this field began at their first call after it.
+    session.usageReadout = foldUsageReadout(session.usageReadout, delta, delta.requestMs);
     recordLastContextTokens(session, iterationContext(delta));
   }
   session.lastIterationIndex = iterationIndex;

package/src/runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs

@@ -0,0 +1,58 @@
+// manager/workflow-switch-notice.mjs
+// A mid-conversation workflow switch (session-runtime/tool-policy-refresh.mjs
+// switchSessionWorkflow) rebuilds the session's prompt and tool surface and
+// stages `session.workflowSwitch`, the one-time notice the next user turn
+// carries in its reminder block. Lifecycle mirrors the working-folder notice
+// (prompt-utils snapshotPendingWorkspaceNotice): snapshot when the turn is
+// built, acknowledge once the provider accepted it, so a failed turn re-sends
+// it. The state object is replaced, never mutated:
+//   from — the workflow the model was last told about (kept across switches
+//          made before a notice reached it);
+//   to   — the workflow the prompt carries now.
+
+function workflowRef(workflow) {
+  const id = String(workflow?.id || '').trim();
+  return id ? { id, name: String(workflow?.name || id).trim() } : null;
+}
+
+/** Stage the notice of a switch from `from` to `to`; a switch back to what the
+ *  model was last told drops it. Returns the staged state or null. */
+export function stageWorkflowSwitchNotice(session, from, to) {
+  const prior = session.workflowSwitch;
+  const told = prior ? prior.from : workflowRef(from);
+  const next = workflowRef(to);
+  if (!next || told?.id === next.id) {
+    delete session.workflowSwitch;
+    return null;
+  }
+  session.workflowSwitch = { version: 1, revision: (Number(prior?.revision) || 0) + 1, from: told, to: next };
+  return session.workflowSwitch;
+}
+
+function workflowNoticeContent({ from, to }) {
+  const before = from?.name || 'the previous workflow';
+  return [
+    '<system-reminder>',
+    '# Workflow Changed',
+    `The workflow changed from ${before} to ${to.name}. Earlier turns of this conversation ran under ${before}; the system prompt was updated in place, so its Active Workflow rules, delegation instructions, available agents and tools are now those of ${to.name}. Follow them from this turn on.`,
+    `Agents already started under ${before} keep running with their own instructions; new delegation uses the current tools and agents.`,
+    '</system-reminder>',
+  ].join('\n');
+}
+
+/**
+ * The workflow notice the next user turn carries, or null.
+ * @returns {{ revision: number, content: string } | null}
+ */
+export function snapshotPendingWorkflowNotice(session) {
+  const pending = session?.workflowSwitch;
+  if (!pending?.to?.id) return null;
+  return { revision: pending.revision, content: workflowNoticeContent(pending) };
+}
+
+/** The notice of `revision` reached the model: nothing is due any more. */
+export function acknowledgePendingWorkflowNotice(session, revision) {
+  if (!session?.workflowSwitch || session.workflowSwitch.revision !== Number(revision)) return false;
+  delete session.workflowSwitch;
+  return true;
+}

package/src/runtime/agent/orchestrator/session/mixy-name.mjs

@@ -0,0 +1,27 @@
+// The representative agent's display name. Its id stays `lead`; the user may
+// rename it (agents/lead/agent.json `name`, user data dir), Mixy by default.
+// Every model- or user-facing string that names it reads this, re-read on each
+// use so a rename applies at once. Text shared across agents (tool schemas,
+// other agents' shared prompt block) says "the representative agent" instead,
+// so a rename never changes cached bytes.
+import { dirname, join } from 'node:path';
+import { mixdogGlobalDir, readSafe } from '../context/skill-catalog.mjs';
+import { mixyIdentityDir } from '../../../shared/agent-store.mjs';
+
+export const DEFAULT_MIXY_NAME = 'Mixy';
+
+/** The display name in a lead manifest (agent.json), else Mixy. */
+export function mixyNameOf(manifest) {
+  const name = typeof manifest?.name === 'string' ? manifest.name.replace(/\s+/g, ' ').trim() : '';
+  return name || DEFAULT_MIXY_NAME;
+}
+
+export function mixyDisplayName() {
+  try {
+    // bots/mixy once Mixy is its own bot, agents/lead before (agent-store.mjs).
+    const dir = mixyIdentityDir(dirname(mixdogGlobalDir('agents')));
+    return mixyNameOf(JSON.parse(readSafe(join(dir, 'agent.json')) || '{}'));
+  } catch {
+    return DEFAULT_MIXY_NAME;
+  }
+}

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -31,6 +31,7 @@ import { bumpUsageMetricsEpoch } from './manager/usage-metrics.mjs';
 import { resetReadStateAfterCompaction } from './read-dedup.mjs';
 import { scheduleCompactionArchive, stampCompactionMessageIds } from './compaction-archive-capture.mjs';
 import { writeStderrBestEffort } from '../../../shared/best-effort-stderr.mjs';
+import { isAgentModeSession } from './agent-mode.mjs';
 import { applyPendingWorkspaceReroot } from './manager/prompt-utils.mjs';
 import { backfillFallbackSessionTitle } from './manager/session-fallback-title.mjs';
 import {
@@ -335,6 +336,32 @@ function reportCompactFailure(ctx, run, compactErr) {
 // Detection is narrow on purpose — signal.aborted or a true AbortError — so
 // the recall pipeline's SYNTHETIC "…aborted: memory … ; head preserved"
 // failure (a real compact failure, message text aside) still escalates.
+function isGenuineCompactOverflow(compactErr) {
+  return (
+    compactErr?.code === 'AGENT_CONTEXT_OVERFLOW' ||
+    compactErr?.name === 'AgentContextOverflowError' ||
+    isContextOverflowError(compactErr)
+  );
+}
+
+// Agent mode retries a failed compaction quietly: the first ordinary failure
+// in a turn neither ends the send nor reaches the user — the context is still
+// under the model's boundary, and the next send's pre-send pass compacts
+// again. A second failure, an abort or a genuine overflow takes the normal path.
+function retryCompactQuietly(ctx, run, compactErr) {
+  const { state } = ctx;
+  // `opts` is the turn's loop options (one per turn; each send builds a new state).
+  if (!isAgentModeSession(state.sessionRef) || !state.opts || state.opts.quietCompactRetryUsed) return false;
+  if (isCompactAbort(state.signal, compactErr) || isGenuineCompactOverflow(compactErr)) return false;
+  state.opts.quietCompactRetryUsed = true;
+  acknowledgeGoalReminder(state.sessionRef, run);
+  reportCompactFailure(ctx, run, compactErr);
+  writeStderrBestEffort(
+    `[loop] pre-send compact failed; retrying on the next send (sess=${state.sessionId || 'unknown'}): ${compactErr?.message || compactErr}\n`
+  );
+  return true;
+}
+
 function throwCompactFailure(ctx, run, compactErr) {
   const { state, compactPolicy, decision } = ctx;
   const { sessionRef, sessionId, signal, model } = state;
@@ -353,11 +380,7 @@ function throwCompactFailure(ctx, run, compactErr) {
   // compact failure, not "latest turn cannot fit" — mislabeling it as
   // overflow hides the real cause and misroutes downstream overflow
   // handling. Surface an explicit compact-failed error.
-  const genuineOverflow =
-    compactErr?.code === 'AGENT_CONTEXT_OVERFLOW' ||
-    compactErr?.name === 'AgentContextOverflowError' ||
-    isContextOverflowError(compactErr);
-  if (genuineOverflow) {
+  if (isGenuineCompactOverflow(compactErr)) {
     throw agentContextOverflowError(
       {
         stage: 'pre_send',
@@ -513,6 +536,10 @@ async function compactBeforeSend(ctx) {
     }
     run.summaryChanged = messagesArrayChanged(messages, run.compacted);
   } catch (compactErr) {
+    if (retryCompactQuietly(ctx, run, compactErr)) {
+      await setStage(opts, 'requesting');
+      return;
+    }
     throwCompactFailure(ctx, run, compactErr);
   }
   await setStage(opts, 'requesting');

package/src/runtime/agent/orchestrator/session/routine-result.d.mts

@@ -0,0 +1,86 @@
+export interface RoutineProvenance {
+  kind: 'schedule' | 'webhook';
+  name: string;
+  status: 'ok' | 'failed';
+  summary?: string;
+  error?: string;
+}
+
+export interface RoutineMessageMeta {
+  source: string;
+  routine: Record<string, unknown>;
+  transcript: { at: number; messageId?: string; attachments?: unknown[] };
+}
+export interface RoutineMessage {
+  role: 'user';
+  content: string;
+  meta: RoutineMessageMeta;
+}
+export interface RoutineNotice {
+  text: string;
+  tone: 'info' | 'warn';
+  routine: Record<string, unknown>;
+  /** Live run notices only (routineRunNotice). */
+  messageId?: string;
+  /** A task report's stored files (handoff-artifacts.mjs). */
+  attachments?: Array<{
+    id: string;
+    attachmentRef: string;
+    kind: string;
+    name: string;
+    mimeType: string;
+    size: number;
+  }>;
+}
+
+export const ROUTINE_RESULT_SOURCE: 'schedule-result';
+export const TASK_LOOP_CAP: number;
+export function routineSummary(text: unknown): string;
+export function routineResultMessage(options: {
+  kind?: 'schedule' | 'webhook';
+  name: string;
+  ok: boolean;
+  text?: unknown;
+  runId?: string | null;
+  runSessionId?: string | null;
+  reason?: string | null;
+  paused?: boolean;
+  at?: number;
+  messageId?: string;
+}): RoutineMessage;
+export function routineOmittedMessage(options: { count: number; at?: number; messageId?: string }): RoutineMessage;
+export function agentTaskMessage(options: {
+  title: string;
+  status: string;
+  text?: unknown;
+  taskSessionId: string;
+  /** 'session': any session other than a task session the agent created. */
+  target?: 'task' | 'session';
+  round?: number;
+  /** false: the report was posted without waking the agent (round-trip cap). */
+  woken?: boolean;
+  /** The files the turn produced (handoff-artifacts.mjs). */
+  files?: ReadonlyArray<{ name: string; path: string; mimeType?: string; size?: number; kind?: string; id?: string }>;
+  omitted?: number;
+  at?: number;
+  messageId?: string;
+}): RoutineMessage;
+export function agentTaskWakePrompt(messages: ReadonlyArray<{ content: string }>): string;
+export function isRoutineResultMessage(message: unknown): boolean;
+export function normalizeRoutineProvenance(value: unknown): RoutineProvenance | null;
+export function routineProvenance(message: unknown): RoutineProvenance | null;
+export function routineResultNotice(message: unknown): RoutineNotice;
+export function routineRunNotice(options: {
+  kind?: 'schedule' | 'webhook';
+  name: string;
+  runId: string;
+  state: string;
+  ok?: boolean;
+  runSessionId?: string | null;
+  messageId?: string;
+}): RoutineNotice;
+export type RoutineHumanNeededOutcome = 'login_required' | 'human_action_required' | 'sensitive_confirmation_required';
+export function routineHumanNeededText(outcome: RoutineHumanNeededOutcome, site: string): string;
+export function routineHumanNeeded(summary: unknown): { outcome: RoutineHumanNeededOutcome; site: string } | null;
+export function routineLoginRequiredText(site: string): string;
+export function routineLoginRequiredSite(summary: unknown): string | null;