mixdog 1.3.1 → 1.3.2

package/src/runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs

@@ -8,6 +8,7 @@ import {
   bridgeSurfaceOutdated,
   sessionToolExposure,
   TOOL_EXPOSURE_BRIDGE,
+  TOOL_EXPOSURE_NATIVE,
   TOOL_SURFACE_MIGRATION_INTENT,
   toolExposureMigrationNeeded,
   toolExposureModeForProvider,
@@ -122,6 +123,17 @@ export function applyAgentToolExposure(session, { existing = false } = {}) {
   const bridge =
     !allowlisted && toolExposureModeForProvider(session.provider, session.wireRoute) === TOOL_EXPOSURE_BRIDGE;
   if (!bridge && before === null) return false;
+  // A native deferred surface (the session runtime builds one) stays one:
+  // re-selected over the tools just resolved, never stripped to the full
+  // array. Native → native is no exposure change, so nothing is tagged.
+  if (!bridge && before === TOOL_EXPOSURE_NATIVE) {
+    session.tools = session.tools.slice();
+    applyDeferredToolSurface(session, session.deferredSurfaceMode || 'full', [], {
+      provider: session.provider,
+      model: session.model,
+    });
+    return false;
+  }
   // A surface an earlier bridge revision built is rebuilt now.
   const outdated = bridgeSurfaceOutdated(session);
   // The tools just resolved are the whole authority: no earlier catalog, MCP

package/src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs

@@ -3,6 +3,7 @@
 // native tool-search payload parsing, bash-session routing, and approval.
 import { isMcpTool } from '../../mcp/client.mjs';
 import { unattendedApprovalPort } from '../human-gate/gate.mjs';
+import { isGrantedRun, runAskOutcome } from '../human-gate/run-policy.mjs';
 import { isBuiltinTool } from '../../tools/builtin.mjs';
 import { isInternalTool } from '../../internal-tools.mjs';
 import { loadSkillToolDependencies } from '../../runtime-core/skill-tool-loading.mjs';
@@ -212,12 +213,13 @@ export async function resolvePreToolAskApproval({
 }) {
   const name = String(toolName || 'tool');
   const reason = String(askReason || 'approval requested by hook').trim();
-  // Unattended runs never auto-approve and have no card: a schedule or webhook
-  // run always holds the request for its owner; a room member does when no
+  // A schedule or webhook run never asks: saving it was the user's grant
+  // (human-gate/run-policy.mjs). A room member is held for its owner when no
   // approval UI is attached (session-runtime/held-requests.mjs).
   const unattended = unattendedApprovalPort();
   const run = unattended?.runOf?.(sessionId) || null;
-  const held = run && (run.kind !== 'room' || typeof toolApprovalHook !== 'function');
+  if (isGrantedRun(run)) return runAskOutcome({ name, request });
+  const held = run && typeof toolApprovalHook !== 'function';
   const ask = held ? unattended.hold : toolApprovalHook;
   if (typeof ask !== 'function') {
     return { denial: formatMissingToolApprovalUiDenial(name, reason) };
@@ -238,8 +240,12 @@ export async function resolvePreToolAskApproval({
     return { denial: `Error: tool "${name}" denied by hook: ${detail}` };
   }
   if (!approvalGranted(approval)) {
-    const detail = approvalReason(approval, reason || 'not approved');
-    return { denial: `Error: tool "${name}" denied by hook: ${detail}`, approval };
+    // A person (or the hold for one) said no: never a policy hook to work around.
+    const detail = String(approvalReason(approval, reason || 'not approved')).replace(/[.\s]+$/, '');
+    return {
+      denial: `Error: tool "${name}" was not approved: ${detail}. Do not retry it or reach the same result another way; report it.`,
+      approval,
+    };
   }
   return { approval };
 }

package/src/runtime/agent/orchestrator/session/manager/ask-turn-auto-effort.mjs

@@ -11,6 +11,7 @@ import { autoEffortModel, turnEffortConfigurationMode } from '../../providers/ef
 import {
   autoEffortApplicable,
   autoEffortBase,
+  clampAutoEffortBase,
   normalizeAutoEffortMode,
   resolveAutoEffort,
 } from '../../providers/auto-effort.mjs';
@@ -58,6 +59,15 @@ export function autoEffortMode() {
   }
 }
 
+/** The global "Auto reasoning base" setting; absent or unreadable is medium. */
+export function autoEffortBaseSetting() {
+  try {
+    return autoEffortBase(readSection('agent')?.autoEffortBase);
+  } catch {
+    return autoEffortBase(undefined);
+  }
+}
+
 /**
  * Starts the judge worker when a session is created or opened on a route that
  * Auto effort can judge, so the first judged turn does not wait for the cold
@@ -102,7 +112,9 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
   if (!request || request.startsWith('<')) return null;
   if (!turnEffortConfigurationMode(session, provider)) return null;
   const chosen = String(session.effort || '').toLowerCase();
-  const base = autoEffortBase(chosen);
+  const options = effortOptionsFor(session.provider, autoEffortModel(session.provider, provider, session.model));
+  const setting = autoEffortBaseSetting();
+  const base = clampAutoEffortBase({ base: setting, options }) ?? autoEffortBase(setting);
   const record = {
     at: new Date().toISOString(),
     sessionId,
@@ -113,7 +125,6 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
     base,
     requestChars: request.length,
   };
-  const options = effortOptionsFor(session.provider, autoEffortModel(session.provider, provider, session.model));
   // No judged outcome can apply when the base is off the model's ladder, so
   // the judge is not asked (in observe mode too: nothing would be logged).
   if (!autoEffortApplicable({ base, options })) {

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

@@ -19,12 +19,15 @@ import { retainedFailedTurnInput, rewindUnansweredPrompt } from './failed-turn-r
 import { buildAgentLoopOptions, trackedToolCallHook } from './ask-turn-loop-options.mjs';
 import { _api_call_with_interrupt } from './ask-call-interrupt.mjs';
 import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
+import { stampTurnHop } from '../../../../shared/bot-hops.mjs';
 
 /** Resolves the provider, builds the user turn and pre-commits it; returns
  *  what the loop and the commit need from this preparation. */
 export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta }) {
   const { turn, runtime, turnSignal, askGeneration, checkpoint, turnToken, startedAt, codexTurnId } = opened;
   const session = turn.session;
+  // Where the turn sits in a bot-to-bot chain (session-runtime/bot-hops.mjs).
+  stampTurnHop(session, transcriptMeta, input.promptSource);
   const retained = input.retryTurnId
     ? retainedFailedTurnInput(session.messages, input.retryTurnId, input.retryAttemptId)
     : null;
@@ -187,6 +190,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
     deferredToolDelta: userTurn.deferredToolDelta,
     goalReminder: userTurn.goalReminder,
     workflowNotice: userTurn.workflowNotice,
+    orchestrationModeNotice: userTurn.orchestrationModeNotice,
     workspaceNotice: userTurn.workspaceNotice,
     setupNotice: userTurn.setupNotice,
   };

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

@@ -20,6 +20,7 @@ import {
   snapshotPendingSetupNotice,
 } from './prompt-utils.mjs';
 import { snapshotPendingWorkflowNotice } from './workflow-switch-notice.mjs';
+import { snapshotPendingOrchestrationModeNotice } from './orchestration-mode-switch-notice.mjs';
 import { codexWireSendOpts } from './session-id.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
@@ -184,8 +185,12 @@ export async function buildUserTurn({
   // A mid-conversation workflow switch: the prompt and tools were rebuilt
   // for the new workflow; this turn tells the model once.
   const workflowNotice = snapshotPendingWorkflowNotice(session);
+  // A mid-conversation orchestration mode switch, after the workflow notice
+  // so the mode it names wins over the one a workflow reminder carries.
+  const orchestrationModeNotice = snapshotPendingOrchestrationModeNotice(session);
   const reminderBlock = [
     workflowNotice?.content || '',
+    orchestrationModeNotice?.content || '',
     workspaceNotice?.content || '',
     setupNotice?.content || '',
     currentTimeBlock ? `<system-reminder>\n# Current Time\n${currentTimeBlock}\n</system-reminder>` : '',
@@ -215,6 +220,7 @@ export async function buildUserTurn({
     deferredToolDelta,
     goalReminder,
     workflowNotice,
+    orchestrationModeNotice,
     workspaceNotice,
     setupNotice,
     userTurnMessage,

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

@@ -10,6 +10,7 @@ import { acknowledgePendingDeferredToolDelta } from '../../runtime-core/deferred
 import { acknowledgePendingGoalReminder } from '../../runtime-core/goal-reminder.mjs';
 import { acknowledgePendingSetupNotice, acknowledgePendingWorkspaceNotice } from './prompt-utils.mjs';
 import { acknowledgePendingWorkflowNotice } from './workflow-switch-notice.mjs';
+import { acknowledgePendingOrchestrationModeNotice } from './orchestration-mode-switch-notice.mjs';
 import {
   finalizePendingMessageDelivery,
   drainPendingMessages,
@@ -141,6 +142,9 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
     acknowledgePendingGoalReminder(session, prepared.goalReminder.revision);
   }
   if (prepared.workflowNotice) acknowledgePendingWorkflowNotice(session, prepared.workflowNotice.revision);
+  if (prepared.orchestrationModeNotice) {
+    acknowledgePendingOrchestrationModeNotice(session, prepared.orchestrationModeNotice.revision);
+  }
   if (prepared.workspaceNotice) {
     acknowledgePendingWorkspaceNotice(session, prepared.workspaceNotice.revision);
   }

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -110,17 +110,12 @@ function withoutLegacyCompactFields(value) {
     delete next[key];
   return next;
 }
-// Handoff-summary timeout scales with transcript size (clear/manual path):
-// default max(60s, ~10s per 25k estimated message tokens) capped at 300s.
-// The summary may run on a slow reasoning model — the session's own model is
-// used whenever the maintenance route is unavailable — where even a small
-// transcript outlives the old 30s floor and a large one the old 120s cap.
-// session.compaction.timeoutMs still overrides.
-function handoffSummaryTimeoutMs(session, messageTokens) {
-  const override = positiveInt(session?.compaction?.timeoutMs);
-  if (override) return override;
-  const scaled = Math.ceil((messageTokens || 0) / 25_000) * 10_000;
-  return Math.min(HANDOFF_TIMEOUT_MAX_MS, Math.max(60_000, scaled));
+// Handoff-summary timeout (clear/manual path): the same 300s as automatic
+// compaction, whatever the transcript size — the summary may run on a slow
+// reasoning model or a stalled provider connection, and a timeout fails the
+// compaction. session.compaction.timeoutMs still overrides.
+function handoffSummaryTimeoutMs(session) {
+  return positiveInt(session?.compaction?.timeoutMs) || HANDOFF_TIMEOUT_MAX_MS;
 }
 /**
  * ONE wiring for the fresh-context handoff pass: provider, summary model,
@@ -144,13 +139,8 @@ export async function runHandoffCompaction({
   provider = null,
   model = null,
   config,
-  messageTokensEst = null,
   requireReduction = false,
 } = {}) {
-  const messageList = Array.isArray(messages) ? messages : [];
-  const transcriptTokens = Number.isFinite(Number(messageTokensEst))
-    ? Number(messageTokensEst)
-    : estimateMessagesTokens(messageList);
   return runFreshContextCompact({
     sessionRef: session,
     messages,
@@ -159,7 +149,7 @@ export async function runHandoffCompaction({
       reserveTokens,
       contextWindow: positiveInt(contextWindow) || positiveInt(session?.contextWindow) || boundaryTokens,
       boundaryTokens,
-      handoffTimeoutMs: handoffSummaryTimeoutMs(session, transcriptTokens),
+      handoffTimeoutMs: handoffSummaryTimeoutMs(session),
     },
     sessionId,
     signal,
@@ -336,7 +326,6 @@ async function runSessionHandoff(plan, opts) {
       provider: opts.provider || getProvider(session.provider) || null,
       model: opts.model,
       config: opts.config,
-      messageTokensEst: plan.beforeMessageTokens,
       requireReduction: plan.requireReduction,
     });
     if (Array.isArray(run.freshContextResult?.messages)) {
@@ -609,7 +598,43 @@ function withAppendedMessages(plan, numbers, appended) {
 const TRANSCRIPT_MOVED_ERROR =
   'compact: the conversation changed while compacting; compaction not applied, run it again';
 
+// Why a compaction took as long as it did: persisted next to lastSummaryModel
+// and echoed as one daemon.log line. Wall time runs start → end of commit; the
+// summary call's own time comes from the handoff pipeline, so the remainder is
+// planning, transcript comparison and the commit below. The archive write is
+// scheduled by the commit and runs later, off it.
+function recordCompactionTiming(plan, freshContextResult, { startedAt, commitStartedAt, afterTokens }) {
+  const { session, resolvedSessionId } = plan;
+  const committedAt = Date.now();
+  const pipeline = freshContextResult?.diagnostics?.pipeline;
+  const summaryMs = pipeline?.generated?.durationMs ?? null;
+  // How the summary ran: a fork of the cached request or the isolated
+  // request, and on which route (session / maintenance / lighter).
+  let summaryRun = null;
+  if (pipeline?.summaryRoute) {
+    const kind = pipeline.generated?.mode === 'shared-prefix' ? 'fork' : 'isolated';
+    summaryRun = `${kind}:${pipeline.summaryRoute}`;
+  }
+  const timing = {
+    lastStartedAt: startedAt,
+    lastCommittedAt: committedAt,
+    lastDurationMs: committedAt - startedAt,
+    lastPipelineMs: pipeline?.totalMs ?? null,
+    lastSummaryMs: summaryMs,
+    lastCommitMs: committedAt - commitStartedAt,
+    lastCompactMode: summaryRun ? `${pipeline.mode}:${summaryRun}` : pipeline?.mode || null,
+  };
+  Object.assign(session.compaction, timing);
+  writeStderrBestEffort(
+    `compaction session=${resolvedSessionId || 'unknown'} source=${freshContextResult?.handoffSource || 'session-local'} ` +
+      `model=${freshContextResult?.summaryModel || '-'} mode=${summaryRun || '-'} total=${timing.lastDurationMs}ms ` +
+      `summary=${summaryMs ?? 0}ms commit=${timing.lastCommitMs}ms ` +
+      `in=${plan.beforeTokens} out=${afterTokens}\n`
+  );
+}
+
 async function commitSessionCompaction(plan, run, compactStartedAt) {
+  const commitStartedAt = Date.now();
   const { session, messages, mode, force, resolvedSessionId, reserveTokens } = plan;
   const { freshContextResult } = run;
   const numbers = await afterCompactionNumbers(plan, run.compacted);
@@ -688,6 +713,7 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
   if (changed) {
     session.pendingCacheBreakIntent = mode === 'auto' ? 'post_turn_compaction' : 'manual_compaction';
   }
+  recordCompactionTiming(plan, freshContextResult, { startedAt: compactStartedAt, commitStartedAt, afterTokens });
   return compactionResult(
     plan,
     { changed, reason: unchangedReason },

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

@@ -0,0 +1,99 @@
+// manager/orchestration-mode-switch-notice.mjs
+// A mid-conversation delegation (orchestration) mode switch
+// (session-runtime/tool-policy-refresh.mjs switchSessionOrchestrationMode),
+// on the workflow switch's pattern (workflow-switch-notice.mjs): the request
+// prefix — system blocks and tool schemas — stays byte-identical, so the
+// provider cache survives. The switch lives in two pieces of session state:
+//   session.orchestrationModeOverlay — while the session's mode differs from
+//     the one its system prompt carries: the prompt's mode (`prompt`), the
+//     new mode, the tools the model must load before using them
+//     (`loadableTools`) and the self-contained reminder (`content`) with the
+//     new mode's rules (the same block BP3 carries). It is folded into the
+//     prompt (and dropped) at the next point where the cache is cold anyway.
+//   session.orchestrationModeSwitch — the notice the next user turn carries
+//     in its reminder block: snapshot when the turn is built, acknowledge once
+//     the provider accepted it. `from` is the mode the model was last told
+//     about, `to` the session's mode now.
+// Every notice says it replaces the earlier ones, so the latest one wins.
+import { normalizeOrchestrationMode } from '../../../../shared/orchestration.mjs';
+import { orchestrationInstructions } from '../../runtime-core/orchestration.mjs';
+
+/** The mode's name as its BP3 block titles it (`# Orchestration Mode: …`). */
+export function orchestrationModeName(value) {
+  const mode = normalizeOrchestrationMode(value);
+  return mode === 'none' ? 'Solo' : `${mode[0].toUpperCase()}${mode.slice(1)}`;
+}
+
+/** The mode the session's system prompt and tool surface were built with. */
+export function promptOrchestrationModeOf(session) {
+  if (session?.workflowOverlay) return session.workflowOverlay.promptOrchestrationMode;
+  if (session?.orchestrationModeOverlay) return session.orchestrationModeOverlay.prompt;
+  return session?.orchestrationMode;
+}
+
+const listed = (names) => names.map((name) => `\`${name}\``).join(', ');
+
+/** The reminder that makes the Lead follow `mode`: self-contained (the mode's
+ *  rules) and superseding every earlier one. `carried`: the system prompt
+ *  carries this mode itself (a switch back, or the overlay folded in). */
+export function orchestrationModeNoticeContent({ mode, carried = false, loadableTools = [] }) {
+  const name = orchestrationModeName(mode);
+  const lead = carried
+    ? `This conversation now uses the ${name} orchestration mode, the one the system prompt carries.`
+    : `This conversation now uses the ${name} orchestration mode. The system prompt's Orchestration Mode no longer applies; follow ${name}'s below instead.`;
+  const pronoun = loadableTools.length === 1 ? 'it' : 'them';
+  return [
+    '<system-reminder>',
+    '# Orchestration Mode Changed',
+    `${lead} This replaces every earlier Orchestration Mode Changed reminder in this conversation.`,
+    ...(loadableTools.length
+      ? [
+          `${listed(loadableTools)}: not among your directly defined tools yet; load ${pronoun} with \`load_tool\` before the first call.`,
+        ]
+      : []),
+    `Agents already started keep running with their own instructions; new delegation follows ${name}.`,
+    '',
+    orchestrationInstructions(mode),
+    '</system-reminder>',
+  ].join('\n');
+}
+
+/** 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 stageOrchestrationModeSwitchNotice(session, from, to) {
+  const prior = session.orchestrationModeSwitch;
+  const told = prior ? prior.from : from;
+  if (!to || told === to) {
+    delete session.orchestrationModeSwitch;
+    return null;
+  }
+  session.orchestrationModeSwitch = {
+    version: 1,
+    revision: (Number(prior?.revision) || 0) + 1,
+    from: told,
+    to,
+  };
+  return session.orchestrationModeSwitch;
+}
+
+/**
+ * The orchestration mode notice the next user turn carries, or null.
+ * @returns {{ revision: number, content: string } | null}
+ */
+export function snapshotPendingOrchestrationModeNotice(session) {
+  const pending = session?.orchestrationModeSwitch;
+  if (!pending?.to) return null;
+  const overlay = session.orchestrationModeOverlay;
+  const content =
+    overlay?.mode === pending.to && overlay.content
+      ? overlay.content
+      : orchestrationModeNoticeContent({ mode: pending.to, carried: true });
+  return { revision: pending.revision, content };
+}
+
+/** The notice of `revision` reached the model: nothing is due any more. */
+export function acknowledgePendingOrchestrationModeNotice(session, revision) {
+  if (!session?.orchestrationModeSwitch || session.orchestrationModeSwitch.revision !== Number(revision)) return false;
+  delete session.orchestrationModeSwitch;
+  return true;
+}

package/src/runtime/agent/orchestrator/session/manager/owner-route-fallbacks.mjs

@@ -0,0 +1,42 @@
+// The fallback models a Lead-class session starts with. Agents get theirs from
+// their spawn preset (agent-child.mjs); a Lead-class session gets its OWNER's:
+// - a coding Lead (new task, task a bot created): the Lead route, i.e. the
+//   preset of `config.default` (workflow-lead);
+// - an agent-mode Lead (a bot's home chat, a room turn, a routine run, or
+//   Mixy's own thread): that bot's own route in its folder (agent.json), so
+//   Mixy and the Lead keep separate chains.
+// The chain applies only while the session runs on the owner's configured
+// primary model. A session the user put on another model (composer picker,
+// New Task) is a deliberate choice and gets none. Route changes recompute it
+// (updateSessionRoute `routeFallbacks`); a fallback hop does not.
+import { loadConfig } from '../../config.mjs';
+import { findPreset } from '../../runtime-core/config-helpers.mjs';
+import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
+import { canonicalRouteProvider } from '../../../../shared/model-route-chain.mjs';
+import { storedBotRoute } from '../../../../shared/agent-store.mjs';
+import { configuredAgentRouteCandidates } from '../../../../shared/agent-route-config.mjs';
+import { CODING_MODE } from '../agent-mode.mjs';
+
+export function ownerRouteFallbacks({ sessionMode, agentId, provider, model, config = null }) {
+  if (!agentId) return [];
+  const cfg = () => config || loadConfig({ secrets: false });
+  let stored;
+  if (sessionMode === CODING_MODE) {
+    stored = findPreset(cfg(), cfg()?.default);
+  } else {
+    // Before the bot split a bot's route is still in the config (Mixy's never).
+    stored = storedBotRoute(agentId) || (agentId === 'lead' ? null : configuredAgentRouteCandidates(cfg(), agentId)[0]);
+  }
+  if (!stored?.fallbacks?.length) return [];
+  let route;
+  try {
+    route = normalizeWorkflowRoute(stored);
+  } catch {
+    return [];
+  }
+  const onPrimary =
+    route &&
+    canonicalRouteProvider(route.provider) === canonicalRouteProvider(provider) &&
+    String(route.model) === String(model);
+  return onPrimary ? route.fallbacks || [] : [];
+}

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -1,5 +1,5 @@
 // Steering / pending-message queue with sync buffering and atomic persistence.
-import { readFileSync } from 'node:fs';
+import { readJsonStateSync } from '../../../../shared/atomic-file.mjs';
 import { loadSession } from '../store.mjs';
 import {
   currentPendingLifecycleToken,
@@ -602,14 +602,8 @@ export function _getPendingMessagesForSession(sessionId) {
   const queued = [...(_sessionPendingMessages.get(sessionId) || []), ...(_pendingPersistBuffers.get(sessionId) || [])];
   // The not-yet-migrated global spool can still hold this session's rows.
   for (const path of [pendingMessagesPath(sessionId), legacyPendingMessagesPath()]) {
-    let raw;
-    try {
-      raw = readFileSync(path, 'utf8');
-    } catch (err) {
-      if (err?.code === 'ENOENT') continue;
-      throw err;
-    }
-    const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
+    // A damaged spool file is kept aside and reads as empty; it never throws.
+    const persisted = normalizePendingStore(readJsonStateSync(path, { fallback: null })).sessions[sessionId];
     if (Array.isArray(persisted)) queued.push(...persisted);
   }
   return queued;

package/src/runtime/agent/orchestrator/session/manager/pending-spool-file.mjs

@@ -17,7 +17,7 @@ export const _pendingPersistTails = new Map();
 export { pendingMessagesPath, touchPendingSessionEntry } from './pending-spool-path.mjs';
 
 // Single spool transaction shape: every mutation touches only `sessionId`'s
-// own shard file, locked, compact and non-fsync; `extra` only ever relaxes the
+// own shard file, locked, compact and durable; `extra` only ever relaxes the
 // lock timeout.
 export function updateSpool(sessionId, mutate, extra = null) {
   return updatePendingShard(sessionId, mutate, extra);

package/src/runtime/agent/orchestrator/session/manager/pending-spool-shard.mjs

@@ -21,7 +21,8 @@ function storeIsEmpty(store) {
   );
 }
 
-// One shard transaction: locked, compact, non-fsync. A shard emptied by the
+// One shard transaction: locked, compact, durable (queued user messages must
+// survive a crash; a damaged shard is kept aside by updateJsonAtomic). A shard emptied by the
 // mutation (or found empty) is deleted under the same lock, so the directory
 // holds only sessions that actually have queued rows.
 async function updateShardFile(key, mutate, extra = null) {
@@ -33,7 +34,6 @@ async function updateShardFile(key, mutate, extra = null) {
         compact: true,
         lock: true,
         mode: PENDING_MESSAGES_MODE,
-        fsync: false,
         ...extra,
       });
       if (storeIsEmpty(result)) {
@@ -50,7 +50,9 @@ async function updateShardFile(key, mutate, extra = null) {
 }
 
 function rowKey(row) {
-  return row && typeof row === 'object' && typeof row.id === 'string' && row.id ? `id:${row.id}` : `json:${JSON.stringify(row)}`;
+  return row && typeof row === 'object' && typeof row.id === 'string' && row.id
+    ? `id:${row.id}`
+    : `json:${JSON.stringify(row)}`;
 }
 
 // Idempotent merge of one legacy bucket into its shard: legacy rows (older)

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

@@ -1,9 +1,15 @@
 // Prompt-layer rules builders. Source revision tracking lives separately so
 // every layer observes deletions, replacements and timestamp rollbacks alike.
+import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { resolvePluginData, mixdogRoot } from '../../../../shared/plugin-paths.mjs';
 import { createRulesSourceCache } from './rules-source-cache.mjs';
+import {
+  AGENT_MODE_DELEGATION,
+  MIXY_CONTACTS_INTRO,
+  orchestrationInstructions,
+} from '../../runtime-core/orchestration.mjs';
 
 // Phase B: Pool B Tier 2 content builder (common rules only).
 // Loaded once per process via createRequire so the CJS module reaches us.
@@ -129,7 +135,7 @@ export function _buildLeadRules({ includeLeadBrief = true, part = 'common' } = {
   );
 }
 
-// One agent-mode rule file (rules/agent-mode): 'conduct', 'mixy' or 'routine'.
+// One agent-mode rule file (rules/agent-mode): 'conduct' or 'mixy'.
 export function _buildAgentModeRules({ part = 'conduct' } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   return buildCachedRules(
@@ -141,6 +147,30 @@ export function _buildAgentModeRules({ part = 'conduct' } = {}) {
   );
 }
 
+// --- Rules revision ---
+// The shipped rule texts a bot thread's prompt embeds — the shared tool
+// policy (canonical variant), every LEAD.md part, the agent-mode files and
+// the orchestration/delegation texts — as one hash. A bot thread stamps it
+// at creation; another value (a release changed a rule) rebuilds its prompt
+// once (session-runtime/tool-policy-refresh.mjs). Built from the cached
+// builders, so a check costs a few stats.
+export function promptRulesRevision() {
+  const hash = createHash('sha256');
+  const texts = [
+    _buildSharedRules(),
+    ...['common', 'coding', 'agent', 'identity'].flatMap((part) =>
+      [true, false].map((includeLeadBrief) => _buildLeadRules({ includeLeadBrief, part }))
+    ),
+    _buildAgentModeRules({ part: 'conduct' }),
+    _buildAgentModeRules({ part: 'mixy' }),
+    AGENT_MODE_DELEGATION,
+    MIXY_CONTACTS_INTRO,
+    ...['none', 'focused', 'balanced', 'swarm'].map(orchestrationInstructions),
+  ];
+  for (const text of texts) hash.update(`${text}\0`);
+  return hash.digest('hex').slice(0, 24);
+}
+
 export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
@@ -162,6 +192,15 @@ export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
 // Trailing BP3 block: the configured response language. Kept out of BP2 so
 // it is the last instruction before the conversation (see
 // 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() {
+  const DATA_DIR = resolvePluginData();
+  return buildCachedRules('buildLeadLanguage', 'lead language', [join(DATA_DIR, 'mixdog-config.json')], {
+    DATA_DIR,
+  });
+}
+
 export function _buildLeadLanguageContext() {
   const DATA_DIR = resolvePluginData();
   return buildCachedRules('buildLeadLanguageContent', 'lead language context', [join(DATA_DIR, 'mixdog-config.json')], {

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

@@ -298,6 +298,16 @@ export function markSessionToolOutputTail(id, tail) {
   entry.toolOutputTail = text ? text.slice(-4000) : null;
   entry.toolOutputTailAt = Date.now();
 }
+// An approval has no wait limit, and the progress watchdog treats a turn with
+// `awaitingUser` as waiting on the user, not stalled. The user's answer is
+// progress: a wait begins and ends with a fresh progress stamp, so the hours
+// spent waiting are never counted as silence once the turn runs again.
+function _stampApprovalProgress(entry) {
+  if (entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
+  const now = Date.now();
+  entry.lastProgressAt = now;
+  entry.updatedAt = now;
+}
 // A turn blocked on the user: a PreToolUse `ask` waiting for the tool
 // approval only the user can give. Published as `awaitingUser: 'approval'` so
 // status surfaces stop presenting the session as working. Counted, because one
@@ -309,6 +319,7 @@ export function beginSessionApprovalWait(id) {
   if (!entry) return () => {};
   entry.approvalWaits = (entry.approvalWaits || 0) + 1;
   entry.awaitingUser = 'approval';
+  _stampApprovalProgress(entry);
   // The waiting turn: the end transition carries the begin's turn even when
   // the turn has settled (askStartedAt cleared) by the time it releases.
   const meta = { turnAt: entry.askStartedAt || 0 };
@@ -321,6 +332,7 @@ export function beginSessionApprovalWait(id) {
     entry.approvalWaits = Math.max(0, (entry.approvalWaits || 0) - 1);
     if (entry.approvalWaits > 0) return;
     entry.awaitingUser = null;
+    _stampApprovalProgress(entry);
     emitSessionApprovalWaitChange(id, null, meta);
   };
 }

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

@@ -19,6 +19,25 @@ export function isTurnInFlight(entry) {
   return IN_FLIGHT_STAGES.has(entry.stage);
 }
 
+// Sessions whose turn was handed to the runtime but has not claimed its
+// controller yet (spawn dispatched, askSession still loading the session).
+// The row already declares work; without this the pool cannot tell that
+// first-turn gap from a worker it lost track of, and reads `unknown`.
+const dispatchedTurns = new Map();
+
+/** Runs `run` (the turn's dispatch) with `id` counted as working until it
+ *  settles, covering the gap before the turn's own runtime entry is in flight. */
+export async function whileTurnDispatched(id, run) {
+  dispatchedTurns.set(id, (dispatchedTurns.get(id) || 0) + 1);
+  try {
+    return await run();
+  } finally {
+    const left = dispatchedTurns.get(id) - 1;
+    if (left > 0) dispatchedTurns.set(id, left);
+    else dispatchedTurns.delete(id);
+  }
+}
+
 const cleanLower = (value) =>
   String(value || '')
     .trim()
@@ -32,6 +51,7 @@ const cleanLower = (value) =>
 export function inFlightSessionActivity() {
   const working = new Set();
   const agentWorking = new Set();
+  for (const id of dispatchedTurns.keys()) working.add(id);
   for (const [id, entry] of runtimeState) {
     if (!isTurnInFlight(entry)) continue;
     working.add(id);