mixdog 1.4.1 → 1.4.2

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

@@ -46,7 +46,8 @@ import { executionFallbacks } from '../../../../shared/model-route-chain.mjs';
 import { ownerRouteFallbacks } from './owner-route-fallbacks.mjs';
 import { applyPendingWorkspaceReroot, refreshSessionBp3Environment } from './prompt-utils.mjs';
 import { isWorktreeBound } from '../../../../shared/worktrees/contract.mjs';
-import { applyAgentToolExposure } from '../loop/tool-exposure-migration.mjs';
+import { applyAgentToolExposure, markToolSurfaceMigrated } from '../loop/tool-exposure-migration.mjs';
+import { useOwnScratchEnvironment } from './session-scratch-environment.mjs';
 import { prewarmSessionAutoEffort } from './ask-turn-auto-effort.mjs';
 import { cancelCacheWarm } from '../cache-warm.mjs';
 
@@ -164,9 +165,9 @@ function resolveSessionRoute(opts, presetObj, profile) {
   const modelName = opts.model || presetObj?.model;
   // opts.tools (caller-supplied) wins over presetObj.tools — caller
   // intent ('tools:readonly' from Pool C, etc.) must override the
-  // preset's default 'full'. Previous priority let HAIKU's tools='full'
-  // shadow Pool C's explicit readonly request, leaking write tools and
-  // bash into a read-only agent.
+  // preset's default 'full'; otherwise a preset's tools='full' would shadow
+  // an explicit readonly request and leak write tools and bash into a
+  // read-only agent.
   const toolPreset = opts.tools || presetObj?.tools || (typeof opts.preset === 'string' ? opts.preset : null) || 'full';
   const effort = Object.hasOwn(opts, 'effort') ? opts.effort || null : presetObj?.effort || null;
   const fast = presetObj?.fast === true || opts.fast === true;
@@ -237,17 +238,21 @@ export function createSession(createOpts) {
       : { ...createOpts, sessionMode };
   // A Lead-class session (actingAgent set) takes its owner's chain while it
   // runs on the owner's primary model; an agent keeps its preset's.
-  const routeFallbacks = actingAgent
-    ? Object.hasOwn(opts, 'routeFallbacks')
+  const explicitRouteFallbacks = Object.hasOwn(opts, 'routeFallbacks');
+  let routeFallbacks;
+  if (actingAgent) {
+    routeFallbacks = explicitRouteFallbacks
       ? opts.routeFallbacks
-      : ownerRouteFallbacks({ sessionMode, agentId: actingAgent, provider: providerName, model: modelName })
-    : executionFallbacks(
-        normalizeWorkflowRoute({
-          provider: providerName,
-          model: modelName,
-          fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.fallbacks,
-        })
-      );
+      : ownerRouteFallbacks({ sessionMode, agentId: actingAgent, provider: providerName, model: modelName });
+  } else {
+    routeFallbacks = executionFallbacks(
+      normalizeWorkflowRoute({
+        provider: providerName,
+        model: modelName,
+        fallbacks: explicitRouteFallbacks ? opts.routeFallbacks : presetObj?.fallbacks,
+      })
+    );
+  }
   // Provider cache strategy — agentRuntime.resolveSync() above is a
   // best-effort injection point (setAgentRuntime() has no live caller
   // today, so that branch never fires); build it directly here so every
@@ -594,6 +599,12 @@ export async function resumeSession(sessionId, preset, options = {}) {
   _recoverTurnCheckpointDurably(session, sessionId);
   _refreshResumedTools(session, sessionId, preset);
   refreshSessionProviderCacheOpts(session);
+  // An archive saved before clear learned to rename it still names the
+  // session it was copied from: a changed prefix is one cache break.
+  if (useOwnScratchEnvironment(session)) {
+    invalidateContextUsageSnapshot(session);
+    markToolSurfaceMigrated(session, 'prompt_fold');
+  }
   // The live session already owns the refreshed tools and desktop scope.
   // Defer the structured clone + worker round-trip so opening a conversation
   // is not blocked on persisting the same in-memory state back to disk.

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

@@ -25,6 +25,18 @@ import { sessionScratchDir } from '../../../../shared/session-scratch.mjs';
 import { delegationDisabled } from './session-tool-surface.mjs';
 import { contextAckMessage } from '../compact/user-message-kind.mjs';
 
+/** What the generated scratch line starts with; the one place that line is recognised. */
+export const SCRATCH_LINE_PREFIX = '- Scratch: ';
+
+/** The environment line naming `sessionId`'s scratch directory, '' without one. */
+export function scratchEnvironmentLine(sessionId) {
+  // Fixed per session id and data dir, so the line never changes across turns.
+  const scratchDir = sessionScratchDir(sessionId);
+  return scratchDir
+    ? `${SCRATCH_LINE_PREFIX}${scratchDir} — this session's scratch directory; TEMP, TMP and TMPDIR in shell commands point here.`
+    : '';
+}
+
 // Preserve the exact pre-layout environment payload: Lead carried the
 // shell preference in Profile Preferences, while any routing surface with
 // shell carried the startup capability line in BP1.
@@ -33,8 +45,6 @@ import { contextAckMessage } from '../compact/user-message-kind.mjs';
 // resolves explicit session signals first and never leaks the daemon's
 // install root (user-cwd.mjs safe fallback chain).
 function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting, sessionId = null) {
-  // Fixed per session id and data dir, so the line never changes across turns.
-  const scratchDir = sessionScratchDir(sessionId);
   const sessionCwdLine = opts.cwd || captureOriginalUserCwd();
   const wantsGitStartupLine = toolsForRouting.some((tool) => tool?.name === 'git');
   let cwdContextLine = '';
@@ -48,9 +58,7 @@ function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting, sessi
   return [
     cwdContextLine,
     `- Shell: ${shellName}. Use ${shellName} syntax unless the user specifies otherwise.`,
-    scratchDir
-      ? `- Scratch: ${scratchDir} — this session's scratch directory; TEMP, TMP and TMPDIR in shell commands point here.`
-      : '',
+    scratchEnvironmentLine(sessionId),
     // Which common tools the shell can run, measured where commands run
     // (login shell on POSIX, this process's PATH on Windows); see
     // runtime-capabilities.mjs. Recorded runs spent a round per session
@@ -113,15 +121,11 @@ export function sessionRolePromptFields(identity, { ownerIsAgent, toolFreeRole,
   const mixy = (identity.agent || MIXY_AGENT_ID) === MIXY_AGENT_ID;
   let roleRules = '';
   if (!skipRules) {
-    roleRules = ownerIsAgent
-      ? _buildAgentRules(identity.agentRulesProfile)
-      : _buildLeadRules({ includeLeadBrief: !delegationFree });
+    roleRules = ownerIsAgent ? _buildAgentRules() : _buildLeadRules({ includeLeadBrief: !delegationFree });
   }
-  const identityLine = agentMode
-    ? agentModeIdentityLine(identity.agent || MIXY_AGENT_ID)
-    : lead
-      ? _buildLeadRules({ includeLeadBrief: !delegationFree, part: 'identity' })
-      : '';
+  let identityLine = '';
+  if (agentMode) identityLine = agentModeIdentityLine(identity.agent || MIXY_AGENT_ID);
+  else if (lead) identityLine = _buildLeadRules({ includeLeadBrief: !delegationFree, part: 'identity' });
   return {
     roleRules,
     ...(lead
@@ -172,7 +176,6 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     skipAgentRules: opts.skipAgentRules === true,
     profileSkip: { ...profile?.skip },
     agent: resolvedAgent,
-    agentRulesProfile: surface.agentRulesProfile,
   };
   const roleFields = sessionRolePromptFields(promptIdentity, {
     ownerIsAgent,

package/src/runtime/agent/orchestrator/session/manager/session-scratch-environment.mjs

@@ -0,0 +1,70 @@
+// manager/session-scratch-environment.mjs
+// A session record that was copied from another session (a clear archive)
+// still names the SOURCE's scratch directory in its generated environment,
+// while its shell commands use its own. This rewrites only that line.
+import {
+  BP3_PART_SEPARATOR,
+  bp3SystemMessage,
+  bpEnvSystemMessage,
+  replaceSystemMessageContent,
+  replaceWorkspaceEnvironment,
+} from './prompt-utils.mjs';
+import { SCRATCH_LINE_PREFIX, scratchEnvironmentLine } from './session-prompt-composition.mjs';
+
+// The first line the generator's own prefix starts is the scratch line.
+function withLine(text, line) {
+  if (typeof text !== 'string') return text;
+  const rows = text.split('\n');
+  const at = rows.findIndex((row) => row.startsWith(SCRATCH_LINE_PREFIX));
+  if (at < 0) return text;
+  rows[at] = line;
+  return rows.join('\n');
+}
+
+// Only the generated environment facts (the first part of the environment
+// tail) hold the line; memory and instruction files never do.
+function tailWithLine(tail, line) {
+  if (typeof tail !== 'string') return tail;
+  const facts = tail.split(BP3_PART_SEPARATOR)[0];
+  const fixed = withLine(facts, line);
+  return fixed === facts ? tail : replaceWorkspaceEnvironment(tail, fixed);
+}
+
+/**
+ * Make `session`'s generated environment name its own scratch directory:
+ * the persisted environment tail, the system block carrying it and the
+ * environment facts of a staged workspace change. Instruction files, memory
+ * and every conversation message stay as they are; a session that already
+ * names its own directory is left byte-identical (message objects included).
+ * System messages are replaced in the session's own array, never mutated.
+ * @returns {boolean} whether the system prefix changed
+ */
+export function useOwnScratchEnvironment(session) {
+  const line = scratchEnvironmentLine(session?.id);
+  if (!line) return false;
+  const oldTail = session.bp3EnvironmentContext;
+  const newTail = tailWithLine(oldTail, line);
+  session.bp3EnvironmentContext = newTail;
+  const pending = session.workspaceReroot;
+  const seen = tailWithLine(pending?.seen?.environmentContext, line);
+  const target = tailWithLine(pending?.target?.environmentContext, line);
+  if (seen !== pending?.seen?.environmentContext || target !== pending?.target?.environmentContext) {
+    // The staged state may be shared with the session this one was copied
+    // from: replace it, never edit it.
+    session.workspaceReroot = {
+      ...pending,
+      seen: { ...pending.seen, environmentContext: seen },
+      target: { ...pending.target, environmentContext: target },
+    };
+  }
+  if (newTail === oldTail || typeof oldTail !== 'string') return false;
+  // The generated environment closes its block (split env block, or the
+  // combined tier3 block after core + session start): swap that suffix.
+  const block = session.bp3EnvSplit === true ? bpEnvSystemMessage(session) : bp3SystemMessage(session);
+  const content = block?.content;
+  const suffix = oldTail.trim();
+  if (typeof content !== 'string' || !suffix || !content.endsWith(suffix)) return false;
+  const next = content.slice(0, -suffix.length) + newTail.trim();
+  // The prefix changed exactly when the system block's text did.
+  return replaceSystemMessageContent(session, block, next) && next !== content;
+}

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

@@ -74,8 +74,6 @@ function schemaOmittedToolNames(toolsForRouting, tools) {
 export function resolveSessionToolSurface(opts, { profile, toolPreset, modelName }) {
   const ownerIsAgent = isAgentOwner(opts.owner);
   const resolvedAgent = opts.agent || opts.role || profile?.taskType || null;
-  const hiddenAgent = getHiddenAgent(resolvedAgent);
-  const isRetrievalAgent = hiddenAgent?.kind === 'retrieval';
   const hasCallerAllow = Array.isArray(opts.schemaAllowedTools);
   const schemaAllowedTools = honoredSchemaAllowlist(opts.schemaAllowedTools, { ownerIsAgent, agent: resolvedAgent });
   // Lead and Agent share the same cwd-scoped Skill inventory. A session that
@@ -112,7 +110,6 @@ export function resolveSessionToolSurface(opts, { profile, toolPreset, modelName
   return {
     ownerIsAgent,
     resolvedAgent,
-    agentRulesProfile: isRetrievalAgent ? 'retrieval' : 'full',
     skills,
     sessionDeny,
     toolPermission,

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

@@ -91,6 +91,11 @@ const ALL_BUILTIN_SESSION_TOOLS = orderSessionTools(
   _dedupByName([...BUILTIN_TOOLS, ...PATCH_TOOL_DEFS, ...CODE_GRAPH_TOOL_DEFS])
 );
 
+/** The read-only filesystem tools (`tools:readonly`), in session route order. */
+export function readOnlyFilesystemTools() {
+  return ALL_BUILTIN_SESSION_TOOLS.filter((t) => READONLY_FS_TOOL_NAMES.has(t.name));
+}
+
 export function resolveSessionTools(
   toolSpec,
   skills,
@@ -154,7 +159,7 @@ function _computeBaseTools(toolSpec, mcp, skillTools) {
           addMany(ALL_BUILTIN_SESSION_TOOLS.filter((t) => FILESYSTEM_TOOL_NAMES.has(t.name)));
           break;
         case 'tools:readonly':
-          addMany(ALL_BUILTIN_SESSION_TOOLS.filter((t) => READONLY_FS_TOOL_NAMES.has(t.name)));
+          addMany(readOnlyFilesystemTools());
           break;
         case 'tools:shell':
         case 'tools:analysis':
@@ -186,8 +191,7 @@ function _computeBaseTools(toolSpec, mcp, skillTools) {
     case 'mcp':
       return orderSessionTools(_dedupByName([...mcp, ...skillTools]));
     case 'readonly': {
-      const readTools = ALL_BUILTIN_SESSION_TOOLS.filter((t) => READONLY_FS_TOOL_NAMES.has(t.name));
-      return orderSessionTools(_dedupByName([...readTools, ...mcp, ...skillTools]));
+      return orderSessionTools(_dedupByName([...readOnlyFilesystemTools(), ...mcp, ...skillTools]));
     }
     // 'full' and any unknown spec.
     default:

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

@@ -195,8 +195,8 @@ function appendObservedTurnOutput(
   }
 }
 
-export function createTurnInterruptionTracker() {
-  const state = {
+function newInterruptionState() {
+  return {
     responseStarted: false,
     partialAssistantContent: '',
     tombstonedAssistantContent: '',
@@ -213,7 +213,10 @@ export function createTurnInterruptionTracker() {
     tombEpoch: 0,
     callsEpoch: 0,
   };
+}
 
+/** Streamed assistant text, including the tombstone of a retracted attempt. */
+function textBufferMethods(state) {
   return {
     recordTextDelta(chunk) {
       const value = String(chunk ?? '');
@@ -263,33 +266,12 @@ export function createTurnInterruptionTracker() {
       state.tombEpoch += 1;
       return true;
     },
-    hasResponseStarted() {
-      return state.responseStarted;
-    },
-    recordReasoningDelta(chunk) {
-      const value = String(chunk ?? '');
-      if (!value) return;
-      state.responseStarted = true;
-      state.partialReasoningContent += value;
-    },
-    recordAssistantText(text) {
-      const value = String(text ?? '');
-      if (!value.trim()) return;
-      state.responseStarted = true;
-      // Buffered providers report the whole segment here; streaming
-      // providers already accumulated the same segment via text deltas.
-      if (!state.partialAssistantContent.trim()) state.partialAssistantContent += value;
-    },
-    markAssistantMessageCommitted() {
-      state.partialAssistantContent = '';
-      state.tombstonedAssistantContent = '';
-      state.partialReasoningContent = '';
-      state.observedToolCalls.clear();
-      state.textEpoch += 1;
-      state.reasoningEpoch += 1;
-      state.tombEpoch += 1;
-      state.callsEpoch += 1;
-    },
+  };
+}
+
+/** Tool calls and early-notified results observed during the turn. */
+function toolObservationMethods(state) {
+  return {
     recordToolCalls(calls, { eagerStarted = false } = {}) {
       for (const call of Array.isArray(calls) ? calls : []) {
         if (!call?.id) continue;
@@ -317,6 +299,42 @@ export function createTurnInterruptionTracker() {
         state.observedToolResults.delete(callId);
       }
     },
+  };
+}
+
+export function createTurnInterruptionTracker() {
+  const state = newInterruptionState();
+
+  return {
+    ...textBufferMethods(state),
+    ...toolObservationMethods(state),
+    hasResponseStarted() {
+      return state.responseStarted;
+    },
+    recordReasoningDelta(chunk) {
+      const value = String(chunk ?? '');
+      if (!value) return;
+      state.responseStarted = true;
+      state.partialReasoningContent += value;
+    },
+    recordAssistantText(text) {
+      const value = String(text ?? '');
+      if (!value.trim()) return;
+      state.responseStarted = true;
+      // Buffered providers report the whole segment here; streaming
+      // providers already accumulated the same segment via text deltas.
+      if (!state.partialAssistantContent.trim()) state.partialAssistantContent += value;
+    },
+    markAssistantMessageCommitted() {
+      state.partialAssistantContent = '';
+      state.tombstonedAssistantContent = '';
+      state.partialReasoningContent = '';
+      state.observedToolCalls.clear();
+      state.textEpoch += 1;
+      state.reasoningEpoch += 1;
+      state.tombEpoch += 1;
+      state.callsEpoch += 1;
+    },
     markProviderSendStarted() {
       state.phase = 'streaming';
     },

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

@@ -0,0 +1,125 @@
+// manager/turn-reap.mjs
+// A turn abandoned by a timeout or stall stops the background shell work that
+// turn started — a job auto-promoted during it, and the survivors its commands
+// left running. Only those: a user cancel, a steering interrupt, a normal
+// finish, and jobs from earlier turns keep their jobs. Only the entry's own
+// turn start is armed, and a new turn clears it, so a reap that runs late
+// never touches a newer turn's work.
+import { cancelBackgroundTasks, getBackgroundTask } from '../../../../shared/background-tasks.mjs';
+import { runtimeState } from './runtime-state.mjs';
+
+// Timeout ownership is explicit and turn-scoped: the code that makes a timeout
+// WIN (the watchdog's own abort, the provider's terminal error) arms the reap
+// itself, and only while nothing else has stopped the turn. An abort that
+// arrives first stays a cancel; an error chain is never read afterwards.
+
+// Codes of the runtime's own timeout/stall errors (stall-policy's
+// streamStalledError / providerTimeoutError, the Gemini stream timeout).
+const PROVIDER_TIMEOUT_CODES = new Set(['ESTREAMSTALL', 'EPROVIDERTIMEOUT', 'EGEMINITIMEOUT']);
+
+/** A timeout is the first thing to stop this session's turn: arm its reap now,
+ *  before the abort propagates. No-op when the turn's controller is already
+ *  aborted (a cancel, interrupt or close won) or no turn runs. */
+export function armTurnTimeout(id) {
+  const entry = runtimeState.get(id);
+  if (!entry || entry.controller?.signal.aborted) return;
+  armTurnShellReap(id, entry);
+}
+
+/** The turn ended with a provider timeout/stall error that no retry recovered
+ *  from: arm only while the turn's own signal is un-aborted and the error
+ *  itself carries a timeout code or the producer's own `streamStalled` flag. */
+export function armTurnTimeoutOnProviderError(id, entry, turnSignal, err) {
+  if (turnSignal?.aborted) return;
+  if (!PROVIDER_TIMEOUT_CODES.has(err?.code) && err?.streamStalled !== true) return;
+  armTurnShellReap(id, entry);
+}
+
+// session id -> jobs stopped by a timeout reap, until the owner's handoff
+// reports them (or the session's next turn starts).
+const stoppedJobs = new Map();
+
+// What the cancel path already produces, read without waiting: a task whose
+// own cancel hook kills (survivors of a finished command) answers with its
+// kill outcome; a promoted job is over once its process tree is no longer
+// tracked.
+function trackStoppedJob(taskId) {
+  const job = { taskId, outcome: null, terminated: false };
+  const kill = getBackgroundTask(taskId)?.cancelOutcome;
+  if (kill) {
+    job.outcome = kill;
+    Promise.resolve(kill).then(
+      (result) => {
+        job.terminated = result?.terminated === true;
+      },
+      () => {}
+    );
+  }
+  return job;
+}
+
+// shell-jobs depends on the session manager, which loads this module, so it is
+// loaded at the first reap. The classification awaits only this module load,
+// never a process; a probe that cannot be loaded leaves a job "still stopping".
+let shellJobProbe = null;
+function loadShellJobProbe() {
+  shellJobProbe ??= import('../../tools/builtin/shell-jobs.mjs').then(
+    (shellJobs) => shellJobs.isShellJobRunning,
+    () => null
+  );
+  return shellJobProbe;
+}
+
+// Confirmed by the runtime's own state, never assumed: a task whose cancel hook
+// kills is confirmed by that kill's `terminated`; a promoted job once neither
+// its native task nor its process-tree tracker is live. Without the probe
+// (shell-jobs not loaded) nothing is confirmed.
+function isConfirmedGone(job, isRunning) {
+  if (job.outcome) return job.terminated;
+  return Boolean(isRunning) && !isRunning(job.taskId);
+}
+
+function reap(id, entry) {
+  loadShellJobProbe();
+  const { taskIds } = cancelBackgroundTasks({
+    surface: 'shell',
+    executionSessionId: id,
+    startedSinceMs: entry.shellReapSince,
+    reason: 'turn-timeout',
+    notify: false,
+  });
+  if (taskIds.length > 0) stoppedJobs.set(id, [...(stoppedJobs.get(id) || []), ...taskIds.map(trackStoppedJob)]);
+}
+
+/** The turn is being abandoned by a timeout: remember when it started and stop
+ *  what it has started so far. A settled (idle) entry has no turn to reap. */
+export function armTurnShellReap(id, entry) {
+  if (!(entry?.askStartedAt > 0) || entry.closed) return;
+  entry.shellReapSince = entry.askStartedAt;
+  reap(id, entry);
+}
+
+/** The abandoned turn has unwound: sweep what it registered while stopping
+ *  (survivors of its aborted commands). No-op unless this turn was armed. */
+export function reapTurnShellJobs(id, entry) {
+  if (entry?.shellReapSince > 0 && !entry.closed && runtimeState.get(id) === entry) reap(id, entry);
+}
+
+/** A new turn owns the session: nothing earlier may be reaped on its account. */
+export function resetTurnShellReap(id, entry) {
+  entry.shellReapSince = null;
+  stoppedJobs.delete(id);
+}
+
+/** The jobs the reap stopped, split by what is known now: `stopped` are
+ *  confirmed gone, `stopping` were killed but their processes are not yet
+ *  confirmed gone (they keep being terminated). */
+export async function takeStoppedShellJobs(id) {
+  const jobs = stoppedJobs.get(id) || [];
+  stoppedJobs.delete(id);
+  if (jobs.length === 0) return { stopped: [], stopping: [] };
+  const isRunning = await loadShellJobProbe();
+  const taskIds = (confirmed) =>
+    jobs.filter((job) => isConfirmedGone(job, isRunning) === confirmed).map((job) => job.taskId);
+  return { stopped: taskIds(true), stopping: taskIds(false) };
+}

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

@@ -3,9 +3,13 @@
 // 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';
+// so a rename never changes those cached bytes. Each other bot's own contact
+// catalog (workflow/context.mjs) names her, so a request naming her finds her.
+// Light imports only: the prompt's contact catalog (workflow/context.mjs) reads
+// the name too, and must not pull the skill catalog and config in with it.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { mixyIdentityDir } from '../../../shared/agent-store.mjs';
 
 export const DEFAULT_MIXY_NAME = 'Mixy';
@@ -19,9 +23,11 @@ export function mixyNameOf(manifest) {
 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')) || '{}'));
+    const dir = mixyIdentityDir(resolvePluginData());
+    return mixyNameOf(JSON.parse(readFileSync(join(dir, 'agent.json'), 'utf8')));
   } catch {
+    // Never throws: prompt composition calls this unguarded, and the name only labels Mixy.
+    // A missing, empty, unreadable or malformed agent.json is the unrenamed default.
     return DEFAULT_MIXY_NAME;
   }
 }

package/src/runtime/agent/orchestrator/session/restart-prefix-parity.fixture.mjs

@@ -1,4 +1,4 @@
-// Child process of restart-prefix-parity.test.mjs: one phase of a scripted
+// Child process of restart-prefix-parity.slow.test.mjs: one phase of a scripted
 // anthropic-oauth session in its own process, so a "restart" is a real new
 // process reading the data dir the previous one left. The fake provider
 // records the request body the real OAuth builder makes for every main-loop