mixdog 1.4.2 → 1.4.3

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';
@@ -31,6 +32,7 @@ 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
@@ -148,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;
 }
@@ -377,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-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';
@@ -522,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.

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 {
@@ -88,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;
@@ -103,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,
+          }),
   };
 }
 
@@ -184,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
@@ -203,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,
@@ -218,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/tool-resolution.mjs

@@ -11,6 +11,7 @@ import { buildSkillToolDefs } from '../../context/collect.mjs';
 import { filterModelEditTools } from '../../../../shared/edit-tool-dialect.mjs';
 import { filterMcpToolsForSession } from '../../runtime-core/extension-scopes.mjs';
 import { ROUTE_TOOL_ORDER } from '../../runtime-core/tool-catalog-data.mjs';
+import { TODO_TOOL } from '../../runtime-core/todo-tool-defs.mjs';
 
 // Merge externally-connected MCP tools with the plugin's in-process tools
 // (registered by agent's toolExecutor adapter). Internal tools are exposed
@@ -110,10 +111,19 @@ export function resolveSessionTools(
   // The shell text follows the system shell the runtime actually resolves
   // (Git Bash/WSL on Windows, pwsh on POSIX), before the edit-dialect rewrite.
   const shellKind = resolveShellFor('default')?.shellType;
-  const base = _computeBaseTools(toolSpec, mcp, skillTools).map((tool) => bindShellKind(tool, shellKind));
+  const base = withTodoTool(_computeBaseTools(toolSpec, mcp, skillTools), toolSpec).map((tool) =>
+    bindShellKind(tool, shellKind)
+  );
   return filterModelEditTools(base, modelName);
 }
 
+// Every session that has tools at all owns a step list (the Lead and each
+// agent alike); an explicit "no tools" spec stays without one.
+function withTodoTool(tools, toolSpec) {
+  if (Array.isArray(toolSpec) && toolSpec.length === 0) return tools;
+  return _dedupByName([...tools, TODO_TOOL]);
+}
+
 export function previewSessionTools(toolSpec, skills = [], options = {}) {
   return resolveSessionTools(toolSpec, skills, options);
 }

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

@@ -1,5 +1,5 @@
 import { contextMessagesSignature } from '../context-utils.mjs';
-import { checkpointMessage, findTurnStart, turnMessagesForCheckpoint } from './turn-checkpoint-journal.mjs';
+import { checkpointMessage } from './turn-checkpoint-journal.mjs';
 
 const TURN_CONTEXT_STATE_VERSION = 1;
 
@@ -29,9 +29,11 @@ function compactCheckpointState(compaction) {
 
 /**
  * Capture provider usage or a post-compact replacement reading against the
- * same canonical message representation persisted by the checkpoint.
+ * same canonical message representation persisted by the checkpoint:
+ * `messages[0..boundary)` is the part recovery takes from the durable record,
+ * the rest is the checkpoint's own (boundary 0 for a self-contained one).
  */
-export function captureTurnCheckpointContextState(session, messages, currentUserContent) {
+export function captureTurnCheckpointContextState(session, messages, boundary) {
   if (!session || !Array.isArray(messages)) return null;
   const providerCount = nonNegativeCount(session.contextPressureBaselineMessageCount);
   const providerTokens = Number(session.contextPressureBaselineTokens);
@@ -54,12 +56,9 @@ export function captureTurnCheckpointContextState(session, messages, currentUser
   }
   if (!kind || anchorCount === null || anchorCount > messages.length) return null;
 
-  const start = findTurnStart(messages, currentUserContent);
-  const fullTranscript = start < 0;
-  const committedPrefixCount = fullTranscript ? 0 : start;
-  const canonicalTurnMessages = fullTranscript
-    ? messages.map(checkpointMessage)
-    : turnMessagesForCheckpoint(messages, currentUserContent);
+  const committedPrefixCount =
+    Number.isInteger(boundary) && boundary >= 0 && boundary <= messages.length ? boundary : 0;
+  const canonicalTurnMessages = messages.slice(committedPrefixCount).map(checkpointMessage);
   const turnMessageCount = anchorCount - committedPrefixCount;
   if (turnMessageCount < 0 || turnMessageCount > canonicalTurnMessages.length) return null;