mixdog 1.2.5 → 1.3.0

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,57 @@ 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),
     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 +168,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 +190,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 +202,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/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.generationMs);
     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/manager.mjs

@@ -122,6 +122,6 @@ export {
 export { deleteSession, listOwnedAgentSessionIds, fenceSessionWrites } from './store.mjs';
 // Read-only parsed-session access (desktop pane peek): no resume, no
 // ownership, no liveness side effects.
-export { loadSession } from './store.mjs';
-export { closeSession, abortSessionTurn, unloadSessionRuntime } from './manager/session-close.mjs';
+export { loadSession, loadSessionStatus } from './store.mjs';
+export { closeSession, closeSessionAsync, abortSessionTurn, unloadSessionRuntime } from './manager/session-close.mjs';
 export { sweepTombstones, startIdleCleanup, stopIdleCleanup } from './manager/idle-cleanup.mjs';

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

@@ -0,0 +1,24 @@
+// 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 { join } from 'node:path';
+import { mixdogGlobalDir, readSafe } from '../context/skill-catalog.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 {
+    return mixyNameOf(JSON.parse(readSafe(join(mixdogGlobalDir('agents'), 'lead', '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/request-fork.mjs

@@ -0,0 +1,47 @@
+// request-fork.mjs — a cache-sharing fork of a provider request the main loop
+// already sent (side-question-store.mjs): its messages unchanged, then the
+// reply that request produced and one appended user turn. Reusing the saved
+// send options keeps the model, system prompt, tools and cache-relevant
+// options identical, so the provider's prompt cache serves the prefix.
+import { collectAssistantToolCallIds } from './context-tool-pairs.mjs';
+import { buildIntermediateAssistantMessage, buildToolCallAssistantMessage } from './loop/assistant-commit.mjs';
+
+// The assistant turn the saved request produced, built the way the loop
+// commits it (without the turn's one-shot transcript metadata), plus a stub
+// result per tool call: the fork only needs each call answered so the
+// request stays well-formed.
+function replyMessages(response, toolStub) {
+  if (!response) return [];
+  const reply = response.toolCalls?.length
+    ? buildToolCallAssistantMessage(response, { calls: response.toolCalls, opts: {} })
+    : buildIntermediateAssistantMessage(response, {});
+  if (!reply) return [];
+  const stubs = collectAssistantToolCallIds(reply).map((id) => ({ role: 'tool', toolCallId: id, content: toolStub }));
+  return [reply, ...stubs];
+}
+
+/**
+ * The fork of a saved request with `prompt` as its final user turn. The
+ * provider continuation state follows the reply when it is appended, exactly
+ * as the main loop's next request would carry it. `sharedCachePrefixCount`
+ * (the shared prefix's message count, which survives model-proxy
+ * serialization) keeps an Anthropic message breakpoint on the shared prefix,
+ * so the fork reads the saved request's cache entry and writes none for its
+ * suffix.
+ */
+export function buildForkedRequest(request, prompt, toolStub) {
+  const reply = replyMessages(request.response, toolStub);
+  const opts = { ...request.opts };
+  if (reply.length && Object.hasOwn(request.response, 'providerState')) {
+    opts.providerState = request.response.providerState;
+  }
+  if (request.messages.length) opts.sharedCachePrefixCount = request.messages.length;
+  const messages = [
+    ...request.messages,
+    ...reply,
+    // A user interjection keeps its own turn (never folded into a preceding
+    // tool result), so the prefix's last block reaches the provider unchanged.
+    { role: 'user', content: prompt, meta: { source: 'steering' } },
+  ];
+  return { messages, opts };
+}

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

@@ -0,0 +1,70 @@
+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 };
+}
+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;
+}
+
+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;
+  round?: 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;