mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/session/manager/rules-cache.mjs

@@ -117,8 +117,7 @@ export function _buildBaseRules({
     .join('\n\n---\n\n');
 }
 
-export function _buildAgentRules(profile = 'full') {
-  const key = String(profile || 'full');
+export function _buildAgentRules() {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
   const RULES_DIR = join(PLUGIN_ROOT, 'rules');
@@ -126,8 +125,8 @@ export function _buildAgentRules(profile = 'full') {
     'buildAgentRoleContent',
     'agent role rules',
     [join(RULES_DIR, 'agent'), join(DATA_DIR, 'mixdog-config.json')],
-    { PLUGIN_ROOT, DATA_DIR, profile: key },
-    key
+    { PLUGIN_ROOT, DATA_DIR },
+    'full'
   );
 }
 
@@ -184,7 +183,12 @@ export function promptRulesRevision() {
   return hash.digest('hex').slice(0, 24);
 }
 
-export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
+// `config`: the prompt settings slice of the runtime's in-memory config
+// (prompt-settings.mjs promptConfigSlice); it keys the cache. Without it the
+// builders read the config file.
+const configVariant = (config) => (config ? JSON.stringify(config) : 'disk');
+
+export function _buildLeadMetaContext({ includeOutputStyle = true, config = null } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
   const RULES_DIR = join(PLUGIN_ROOT, 'rules');
@@ -197,8 +201,8 @@ export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
       join(PLUGIN_ROOT, 'output-styles'),
       join(DATA_DIR, 'output-styles'),
     ],
-    { PLUGIN_ROOT, DATA_DIR, includeOutputStyle },
-    includeOutputStyle ? 'style' : 'no-style'
+    { PLUGIN_ROOT, DATA_DIR, CONFIG: config, includeOutputStyle },
+    `${includeOutputStyle ? 'style' : 'no-style'}\n${configVariant(config)}`
   );
 }
 
@@ -207,21 +211,25 @@ export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
 // rules-builder.cjs buildLeadLanguageContent).
 // The configured response language as {id, name}, or null (a rule's `language`
 // condition compares the id; its text's {language} is the name).
-export function _buildLeadLanguage() {
+export function _buildLeadLanguage({ config = null } = {}) {
   const DATA_DIR = resolvePluginData();
-  return buildCachedRules('buildLeadLanguage', 'lead language', [join(DATA_DIR, 'mixdog-config.json')], {
-    DATA_DIR,
-  });
+  return buildCachedRules(
+    'buildLeadLanguage',
+    'lead language',
+    [join(DATA_DIR, 'mixdog-config.json')],
+    { DATA_DIR, CONFIG: config },
+    configVariant(config)
+  );
 }
 
-export function _buildLeadLanguageContext({ includeOutputStyle = true } = {}) {
+export function _buildLeadLanguageContext({ includeOutputStyle = true, config = null } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
   return buildCachedRules(
     'buildLeadLanguageContent',
     'lead language context',
     [join(DATA_DIR, 'mixdog-config.json'), join(PLUGIN_ROOT, 'output-styles'), join(DATA_DIR, 'output-styles')],
-    { PLUGIN_ROOT, DATA_DIR, includeOutputStyle },
-    includeOutputStyle ? 'style' : 'no-style'
+    { PLUGIN_ROOT, DATA_DIR, CONFIG: config, includeOutputStyle },
+    `${includeOutputStyle ? 'style' : 'no-style'}\n${configVariant(config)}`
   );
 }

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

@@ -35,6 +35,7 @@ import { registerSessionPurgeHook } from '../store.mjs';
 import { finishComputerTurn } from '../../../../computer-bridge/client.mjs';
 import { configureUsageMetricsRuntime, dropMetricSeenState, bumpUsageMetricsTurnId } from './usage-metrics.mjs';
 import { runtimeState as _runtimeState, isTurnInFlight } from './runtime-state.mjs';
+import { resetTurnShellReap } from './turn-reap.mjs';
 
 export { IN_FLIGHT_STAGES, inFlightSessionActivity } from './runtime-state.mjs';
 
@@ -216,6 +217,7 @@ export function markSessionAskStart(id) {
   // after provider admission (the scheduler emits stage=requesting).
   const now = Date.now();
   entry.askStartedAt = now;
+  resetTurnShellReap(id, entry);
   _setLogicalModelRequest(entry, null);
   entry.lastProgressAt = now;
   entry.updatedAt = now;

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

@@ -23,6 +23,7 @@ import {
   _clearSessionRuntime,
 } from './runtime-liveness.mjs';
 import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
+import { forgetUnsettledTurn } from './turn-durability.mjs';
 import { forgetSessionSaveBaseline } from '../store/save-worker.mjs';
 import { publishSessionPersistence } from '../store/session-persistence-events.mjs';
 import { forgetSessionLoadCache } from '../store/load-cache.mjs';
@@ -30,6 +31,8 @@ import { releaseReadSnapshotScope } from '../../tools/builtin/snapshot-store.mjs
 import { cancelOwnedShellTrees } from '../../tools/lib/owned-shell-trees.mjs';
 import { noteShellOwnerSessionClosed } from '../../tools/builtin/lib/shell-job-records.mjs';
 import { forgetSideQuestion } from '../side-question-store.mjs';
+import { cancelBackgroundTasks } from '../../../../shared/background-tasks.mjs';
+import { releaseWorkerSnapshots } from '../../../../shared/worktrees/worker-snapshots.mjs';
 
 /**
  * Close a session. Plants a `closed=true` tombstone on disk with a bumped
@@ -147,6 +150,7 @@ function finishClose({ id, reason, tombstone, entry, closeSnapshot, newGen, outc
   _stopToolActivityHeartbeat(id);
   cancelOwnedShellProcesses({ id, reason, tombstone });
   clearTurnCheckpoint(id);
+  forgetUnsettledTurn(id);
   teardownSessionRuntime({ id, entry, reason, tombstone, newGen });
   return true;
 }
@@ -214,6 +218,12 @@ function cancelOwnedShellProcesses({ id, reason, tombstone }) {
   } catch {
     unconfirmed();
   }
+  // What a finished command left running is a tracked task, not an owned tree.
+  try {
+    cancelBackgroundTasks({ surface: 'shell', executionSessionId: id, reason, notify: false });
+  } catch {
+    unconfirmed();
+  }
   noteShellOwnerSessionClosed(id);
 }
 
@@ -370,6 +380,8 @@ export function unloadSessionRuntime(id, reason = 'runtime-unload') {
   closeProviderConnections(id, `runtime-unload:${reason}`);
   releaseSessionReadCaches(id);
   _clearSessionRuntime(id);
+  // A settled worker turn's read-only snapshots go with it (only ones it made).
+  void releaseWorkerSnapshots(id).catch(() => {});
   if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
     try {
       process.stderr.write(`[agent-unload] session=${id} reason=${reason}\n`);

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

@@ -14,6 +14,7 @@ import { runSessionCompaction, resolveSessionCompactionPolicy } from './compacti
 import {
   currentContextEstimateTokens,
   invalidateContextUsageSnapshot,
+  invalidateProviderContextBaseline,
   recordContextUsageSnapshot,
   resolveGaugeContextTokens,
 } from '../loop/compact-policy.mjs';
@@ -26,6 +27,8 @@ import {
 import { getProvider } from '../../providers/registry.mjs';
 import { isSessionCompactionBlocked, getSessionAbortSignal, _runtimeEntries } from './runtime-liveness.mjs';
 import { mintSessionId } from './session-id.mjs';
+import { useOwnScratchEnvironment } from './session-scratch-environment.mjs';
+import { rebindToChangedPrefix } from '../thinking-binding.mjs';
 import { hideCompactionArchive } from '../compaction-archive-capture.mjs';
 import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { forgetSideQuestion } from '../side-question-store.mjs';
@@ -234,6 +237,18 @@ function forkOutgoingTranscript(session, messages, now, archiveAs = '') {
       ...clearedTokenAccounting(now),
     };
     delete fork.liveTurnMessages;
+    // The spread copied the source's environment: the fork names its own
+    // scratch directory (its shell commands use it), not the source's.
+    if (useOwnScratchEnvironment(fork)) {
+      // The system prefix changed: thinking stored in the copy was bound to the
+      // source's prefix (and an open tool round ended), and every measurement
+      // taken against it is stale. Resume then finds a matching prefix and
+      // would repair nothing.
+      fork.messages = rebindToChangedPrefix(fork.messages);
+      delete fork._providerPrefixGuardState;
+      invalidateContextUsageSnapshot(fork);
+      invalidateProviderContextBaseline(fork);
+    }
     // The archive sidecar belongs to the source id; the fork has none.
     if (fork.compaction?.archive) {
       fork.compaction = { ...fork.compaction };

package/src/runtime/agent/orchestrator/session/manager/session-fallback-title.mjs

@@ -68,7 +68,7 @@ export function fallbackTitleFromMessages(messages) {
 /** Fills `session.title` only when missing. Never touches a locked (manual/AI)
  *  or generated title, and leaves generatedTitleStage unset so
  *  updateSessionGeneratedTitle can still upgrade it. The caller persists. */
-export function applyFallbackSessionTitle(session, title) {
+function applyFallbackSessionTitle(session, title) {
   if (!session || !isUsableTitle(title) || isUsableTitle(session.title)) return false;
   if (session.titleLocked === true || session.generatedTitleStage) return false;
   session.title = title;

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

@@ -7,6 +7,7 @@ import { getProvider } from '../../providers/registry.mjs';
 import { invalidateContextUsageSnapshot, invalidateProviderContextBaseline } from '../loop/compact-policy.mjs';
 import { saveSession, saveSessionAsync, saveSessionAsyncDeferred, loadSession, setLiveSession } from '../store.mjs';
 import { _liveSessions } from '../store/live-state.mjs';
+import { _getRuntimeEntry } from './runtime-liveness.mjs';
 import { _recoverTurnCheckpointDurably } from './turn-checkpoint-recovery.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { AGENT_MODE, resolveSessionMode, sessionModeOf } from '../agent-mode.mjs';
@@ -46,7 +47,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 +166,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 +239,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
@@ -517,6 +523,36 @@ export function updateSessionRoute(id, route = {}, options = {}) {
   return session;
 }
 
+/**
+ * A route saved for a session while its turn runs: held as
+ * `session.heldRoute` (on the object the running turn commits, so its save
+ * persists it) and applied at the session's next turn boundary
+ * (applyHeldSessionRoute). A later hold replaces an earlier one; `route`
+ * null drops the hold (the route was saved back to the running one).
+ */
+export function holdSessionRoute(id, route = {}) {
+  if (!id) return null;
+  const targets = new Set([_getRuntimeEntry(id)?.session, loadSession(id)]);
+  let held = null;
+  for (const session of targets) {
+    if (session?.id !== id || session.closed === true) continue;
+    if (route) session.heldRoute = { ...route };
+    else delete session.heldRoute;
+    held = session;
+  }
+  return held;
+}
+
+/** A held route takes effect before the turn opens on `session`. */
+export function applyHeldSessionRoute(session) {
+  const route = session?.heldRoute;
+  if (!route) return session;
+  delete session.heldRoute;
+  const crossProvider =
+    (route.provider && route.provider !== session.provider) || (route.model && route.model !== session.model);
+  return updateSessionRoute(session.id, route, { session, crossProvider }) || session;
+}
+
 // --- resume (reload tools for a stored session) ---
 // Interrupted-turn recovery lives in turn-checkpoint-recovery.mjs; the
 // prepared tool surface it consumes is cached in prepared-resume-cache.mjs.
@@ -594,6 +630,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-lock.mjs

@@ -29,7 +29,38 @@ export function acquireSessionLock(sessionId, signal = null) {
   };
   const unlock = () => releaseSlot();
   if (!signal) return previousReady.then(() => unlock);
+  return waitForSlot(sessionId, signal, previousReady, releaseSlot, unlock);
+}
+
+/** The lock only when nobody holds it or waits for it: the unlock now, or
+ *  null. Synchronous, so a caller can check and act with no turn starting
+ *  in between (askSession takes this lock for every turn). */
+export function tryAcquireSessionLock(sessionId) {
+  if (_sessionLocks.has(sessionId)) return null;
+  let release;
+  const entry = {
+    promise: new Promise((r) => {
+      release = r;
+    }),
+    count: 1,
+  };
+  _sessionLocks.set(sessionId, entry);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    entry.count--;
+    if (entry.count === 0 && _sessionLocks.get(sessionId) === entry) _sessionLocks.delete(sessionId);
+    release();
+  };
+}
+
+/** Someone waits for the lock behind its holder (a turn about to start). */
+export function sessionLockContended(sessionId) {
+  return (_sessionLocks.get(sessionId)?.count ?? 0) > 1;
+}
 
+function waitForSlot(sessionId, signal, previousReady, releaseSlot, unlock) {
   // A cancelled waiter must reject immediately without opening a hole in the
   // mutex. Its reserved slot is skipped only after the previous holder exits,
   // so later waiters still cannot overlap the live owner.

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

@@ -4,6 +4,8 @@
 // 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 { normalizeInstructionFilesMode } from '../../../../shared/instruction-files-mode.mjs';
+import { promptConfigSlice, promptSettingsRecord } from './prompt-settings.mjs';
 import { agentModeIdentityLine } from '../../context/role-instructions.mjs';
 import { AGENT_MODE, sessionModeOf } from '../agent-mode.mjs';
 import { MIXY_AGENT_ID } from '../agent-home.mjs';
@@ -13,6 +15,7 @@ import {
   _buildAgentModeRules,
   _buildLeadRules,
   _buildLeadMetaContext,
+  _buildLeadLanguage,
   _buildLeadLanguageContext,
 } from './rules-cache.mjs';
 import {
@@ -25,6 +28,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 +48,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 +61,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
@@ -80,7 +91,7 @@ function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting, sessi
  * none.
  * @returns {{ environmentContext: string|undefined, instructionFilesContext: string|undefined }}
  */
-export function buildWorkspacePromptContext(session, cwd) {
+export function buildWorkspacePromptContext(session, cwd, { instructionFilesMode } = {}) {
   const ownerIsAgent = session?.owner === 'agent';
   const toolFreeRole =
     ownerIsAgent && Array.isArray(session?.schemaAllowedTools) && session.schemaAllowedTools.length === 0;
@@ -95,7 +106,14 @@ export function buildWorkspacePromptContext(session, cwd) {
     instructionFilesContext:
       session?.skipInstructionFiles === true || sessionModeOf(session) === AGENT_MODE
         ? undefined
-        : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd }),
+        : loadInstructionFilesContext({
+            // A session runtime passes its in-memory setting; others read the file.
+            mode:
+              instructionFilesMode === undefined
+                ? configuredInstructionFilesMode()
+                : normalizeInstructionFilesMode(instructionFilesMode),
+            cwd,
+          }),
   };
 }
 
@@ -113,15 +131,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 +186,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,
@@ -181,10 +194,13 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     sessionMode,
   });
   const leadOnly = !skipAgentRules && !ownerIsAgent;
-  const metaContext = leadOnly ? _buildLeadMetaContext({ includeOutputStyle: !agentMode }) : '';
+  // The runtime's in-memory settings (a session runtime passes its config;
+  // other callers read the config file).
+  const config = promptConfigSlice(opts.promptConfig);
+  const metaContext = leadOnly ? _buildLeadMetaContext({ includeOutputStyle: !agentMode, config }) : '';
   // Lead-only response language; closes the environment block so no English
   // system text (session/shell/git lines) follows it.
-  const languageContext = leadOnly ? _buildLeadLanguageContext({ includeOutputStyle: !agentMode }) : '';
+  const languageContext = leadOnly ? _buildLeadLanguageContext({ includeOutputStyle: !agentMode, config }) : '';
   // Cwd, shell and repository facts only serve tool calls; a tool-free role
   // gets none, which also keeps its prompt identical across projects.
   const shellEnvironmentContext = toolFreeRole
@@ -200,7 +216,10 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
   const instructionFilesContext =
     toolFreeRole || profile?.skip?.claudemd || agentMode
       ? ''
-      : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd: opts.cwd });
+      : loadInstructionFilesContext({
+          mode: config ? normalizeInstructionFilesMode(config.instructionFiles) : configuredInstructionFilesMode(),
+          cwd: opts.cwd,
+        });
   const composed = composeSystemPrompt({
     ...roleFields,
     agentRules: injectedRules || undefined,
@@ -215,7 +234,27 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     environmentContext: shellEnvironmentContext,
     provider: providerName || null,
   });
-  return { ...composed, environmentTailContext, promptIdentity };
+  // What the prompt presents of the prompt settings (prompt-settings.mjs).
+  const promptSettings = promptSettingsRecord({
+    meta: metaContext,
+    workflow: opts.workflowContext || '',
+    // A coding Lead's mode text (an agent-mode Lead's delegation block is fixed).
+    ...(ownerIsAgent || agentMode
+      ? {}
+      : {
+          orchestration: String(opts.leadWorkflowParts?.orchestrationContext || ''),
+          orchestrationMode: opts.orchestrationMode || '',
+        }),
+    skills: buildSkillManifest(skills),
+    language: languageContext,
+    instructionFiles: profile?.skip?.claudemd ? '' : instructionFilesContext,
+    coreMemory: profile?.skip?.memory ? '' : opts.coreMemoryContext || '',
+    instructionFilesMode: config
+      ? normalizeInstructionFilesMode(config.instructionFiles)
+      : configuredInstructionFilesMode(),
+  });
+  const responseLanguage = leadOnly ? _buildLeadLanguage({ config }) || null : null;
+  return { ...composed, environmentTailContext, promptIdentity, promptSettings, responseLanguage };
 }
 
 // 4-BP layout (see composeSystemPrompt docs):

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

@@ -168,6 +168,8 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     sessionMode: opts.sessionMode,
     bp3CoreContext: prompt.sessionMarkerCore,
     promptIdentity: prompt.promptIdentity,
+    ...(prompt.promptSettings ? { promptSettings: prompt.promptSettings } : {}),
+    ...(prompt.responseLanguage !== undefined ? { responseLanguage: prompt.responseLanguage } : {}),
     callerDisallowedTools: [...(opts.callerDisallowedTools ?? opts.disallowedTools ?? [])],
     bp3EnvironmentContext: prompt.environmentTailContext,
     // BP3 core and the volatile environment live in SEPARATE system

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,