mixdog 1.2.1 → 1.2.2

package/src/runtime/agent/orchestrator/runtime-core/orchestration.mjs

@@ -2,16 +2,14 @@ import { normalizeOrchestrationMode } from '../../../shared/orchestration.mjs';
 
 const BATCHING = {
   focused: `Lead executes the main scope directly. Delegate only substantial,
-self-contained supporting work. Batch closely related tasks into one
-coherent assignment; do not split them merely to increase parallelism.`,
-  balanced: `Delegate independent work by coherent feature or module. Batch related
-tasks within the same change scope into one assignment rather than
-splitting every file or step.
-If the plan has only one scope, Lead executes it directly.`,
-  swarm: `Delegate every substantial independent scope to its own agent. Treat
-disjoint file or module sets as independent and merge scopes only on a true
-output dependency. Prefer parallel scopes over sequential slices in one agent.
-If the plan has only one scope, Lead executes it directly.`,
+self-contained supporting work, one agent per role; batch related tasks
+rather than splitting them for parallelism.`,
+  balanced: `Delegate independent work by coherent feature or module, one agent per
+scope. Batch related tasks within the same change scope rather than
+splitting every file or step.`,
+  swarm: `Delegate every independent scope to its own agent. Treat disjoint file or
+module sets as independent and merge scopes only on a true output
+dependency. Prefer parallel scopes over sequential slices in one agent.`,
 };
 
 const SOLO = `# Orchestration Mode: Solo
@@ -27,6 +25,12 @@ export function orchestrationInstructions(value) {
 
 ${BATCHING[mode]}
 
+The mode sets how work splits; an agent's description sets its role and when
+it runs. Splitting applies to every role alike — implementation, review,
+investigation, writing — by file, module, commit range or risk area.
+If the plan has only one implementation scope, Lead executes it directly; a
+role tied to a point in the work, such as the final check, still runs then.
+
 Delegation is for work whose size justifies a brief. When the brief would have
 to spell out the edits themselves — a few localized changes whose sites Lead
 already holds — Lead makes them directly in every mode; the number of files or
@@ -34,10 +38,9 @@ scopes does not change this.
 
 Dispatch all ready independent scopes in one turn. Only a scope that requires
 another's output waits. Brief each agent as the Lead rules describe.
-Use only available agents; Lead handles work without a suitable agent.
-
-If the reviewer is disabled or unavailable, Lead alone reviews the result
-against the approved scope and performs the required verification. Do not
-change settings, enable the reviewer, or delegate review to a substitute agent.
-Do not skip review or describe Lead's own review as independent review.`;
+Use only available agents; when none fits a role, Lead does that work itself
+and never changes settings to enable one. If the reviewer is disabled or
+unavailable, Lead alone reviews the result against the approved scope and
+performs the required verification, without a substitute agent; never skip
+review or describe Lead's own review as independent.`;
 }

package/src/runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs

@@ -1,17 +1,5 @@
 // Plugin/project MCP server discovery + normalization, and skill-file counting.
-import {
-  chmodSync,
-  closeSync,
-  existsSync,
-  fsyncSync,
-  openSync,
-  readFileSync,
-  readdirSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 import { clean } from './session-text.mjs';
 import {
@@ -54,90 +42,6 @@ export function mergeMcpServerConfig(existing, next) {
   return { ...merged, ...next };
 }
 
-function readProjectMcpDocument(cwd, allowMissing = false) {
-  const path = join(cwd || '.', '.mcp.json');
-  if (!existsSync(path)) {
-    if (allowMissing) return { path, raw: { mcpServers: {} }, usesWrapper: true };
-    throw new Error(`MCP config file not found: ${path}`);
-  }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(path, 'utf8'));
-  } catch (error) {
-    throw new Error(`cannot read ${path}: ${error?.message || String(error)}`);
-  }
-  if (!isPlainObject(raw)) throw new Error(`unexpected .mcp.json shape at ${path}`);
-  if (Object.hasOwn(raw, 'mcpServers') && !isPlainObject(raw.mcpServers)) {
-    throw new Error(`unexpected .mcp.json shape at ${path}`);
-  }
-  const usesWrapper = isPlainObject(raw.mcpServers);
-  return { path, raw, usesWrapper };
-}
-
-function writeProjectMcpDocument(path, raw) {
-  let mode = 0o644;
-  try {
-    mode = statSync(path).mode;
-  } catch {
-    /* new file */
-  }
-  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
-  let fd = null;
-  try {
-    fd = openSync(tempPath, 'w', mode);
-    writeFileSync(fd, `${JSON.stringify(raw, null, 2)}\n`, 'utf8');
-    fsyncSync(fd);
-    closeSync(fd);
-    fd = null;
-    chmodSync(tempPath, mode);
-    renameSync(tempPath, path);
-  } catch (error) {
-    if (fd !== null) {
-      try {
-        closeSync(fd);
-      } catch {
-        /* best effort */
-      }
-    }
-    try {
-      unlinkSync(tempPath);
-    } catch {
-      /* best effort */
-    }
-    throw error;
-  }
-}
-
-// The stored key for `key`: an exact own key first, else one that trims to it.
-function mcpEntryKey(map, key) {
-  return Object.hasOwn(map, key) ? key : Object.keys(map).find((candidate) => String(candidate || '').trim() === key);
-}
-
-export function readProjectMcpServerConfig(cwd, name) {
-  const { raw, usesWrapper } = readProjectMcpDocument(cwd);
-  const map = usesWrapper ? raw.mcpServers : raw;
-  const entryKey = mcpEntryKey(map, String(name || '').trim());
-  return entryKey && isPlainObject(map[entryKey]) ? { name: entryKey, config: { ...map[entryKey] } } : null;
-}
-
-export function saveProjectMcpServer(cwd, { originalName = '', name, config }) {
-  const { path, raw, usesWrapper } = readProjectMcpDocument(cwd, !originalName);
-  const map = usesWrapper ? raw.mcpServers : raw;
-  const target = String(name || '').trim();
-  const original = String(originalName || '').trim();
-  if (!target) throw new Error('MCP server name is required');
-  const entryKey = original ? mcpEntryKey(map, original) : null;
-  if (original && !entryKey) throw new Error(`MCP server not defined in ${path}: ${original}`);
-  if (target !== entryKey && Object.hasOwn(map, target)) {
-    throw new Error(`MCP server already exists in ${path}: ${target}`);
-  }
-  const existing = entryKey ? map[entryKey] : {};
-  if (entryKey && entryKey !== target) delete map[entryKey];
-  map[target] = mergeMcpServerConfig(existing, config);
-  writeProjectMcpDocument(path, raw);
-  return { name: target, source: 'project', path, config: { ...map[target] } };
-}
-
 // Manifest + contained-path resolution live in the shared module so skill
 // discovery and this status surface read the same roots.
 export { pluginManifest, resolveContainedPluginPath };

package/src/runtime/agent/orchestrator/session/catalog-db/schema.mjs

@@ -11,7 +11,7 @@ import { createHash } from 'node:crypto';
 
 /** Bumped whenever the table layout or a codec changes: the DB is then
  *  dropped and backfilled again from the JSON catalog. */
-export const SCHEMA_VERSION = 3;
+export const SCHEMA_VERSION = 4;
 /** PRAGMA application_id ('MXSC'): a file without it is not this catalog. */
 export const APPLICATION_ID = 0x4d585343;
 
@@ -57,6 +57,8 @@ const FIELDS = [
   ['detachedReason', 'detached_reason', 'loose'],
   // importOrigin.key of an imported conversation (schema 3).
   ['importKey', 'import_key', 'loose'],
+  // Source session of an inherited (forked) session (schema 4).
+  ['inheritedFromSessionId', 'inherited_from_session_id', 'loose'],
 ];
 
 const COLUMN_TYPES = { text: 'TEXT', real: 'REAL', int: 'INTEGER', bool: 'INTEGER', json: 'TEXT', optjson: 'TEXT' };

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -8,6 +8,7 @@ import { resolveLiveToolCwd } from './tool-exec.mjs';
 import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { addUsage, usageDeltaEvent } from './usage.mjs';
 import { prepareProviderRequest } from './request-boundary.mjs';
+import { applyStepEffort } from './step-auto-effort.mjs';
 import { projectProviderRequest } from './request-projection.mjs';
 import { traceProviderSend, traceOutputTruncation } from './diagnostics.mjs';
 import { createEagerDispatcher } from '../eager-dispatch.mjs';
@@ -132,6 +133,9 @@ export async function sendProviderRequest(state, round) {
   const sendStartedAt = Date.now();
   const preSendMs = sendStartedAt - round.iterT0;
   const toolResumeMs = state.lastToolBatchEndedAt ? sendStartedAt - state.lastToolBatchEndedAt : null;
+  // The step judgment ran beside opening the iteration; wait for it only up to
+  // its grace, then it rides on this request or on the next.
+  await applyStepEffort(state);
   // Every attempt is built from the live transcript, so a compaction between
   // attempts reaches the provider; a pending image strip only filters it.
   const messageSource = state.imageStrip

package/src/runtime/agent/orchestrator/session/loop/step-auto-effort.mjs

@@ -8,12 +8,13 @@
  * later request rebuilds the same history and the prompt cache keeps hitting.
  * A judge that is missing, slow or failing leaves the step at the effort in
  * force (the turn's or the previous step's).
- * A custom route (snapshot mode 'custom') has no mid-conversation update: the
- * judged effort, snapped onto the model's levels, becomes the effort of the
- * turn's following requests.
+ * A custom route snaps the judged effort onto the model's levels. Without a
+ * mid-conversation update (snapshot mode 'custom') it becomes the effort of
+ * the turn's following requests; a custom GPT-6+ Responses route (mode
+ * 'responses') also marks it as the update.
  */
 import { resolveAutoEffort } from '../../providers/auto-effort.mjs';
-import { resolveCustomReasoning } from '../../providers/custom-reasoning.mjs';
+import { isCustomProviderName, resolveCustomReasoning } from '../../providers/custom-reasoning.mjs';
 import { autoEffortModel, stepEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import { effortOptionsFor } from '../../runtime-core/effort.mjs';
 import { judgeTurn, recordEffortDecision } from '../../../../effort-judge/judge-client.mjs';
@@ -35,12 +36,58 @@ const argText = (args) =>
     .slice(0, 600)
     .join('');
 
+// A judgment runs beside the next iteration instead of in front of it. Its
+// record lives on the loop state (`state.stepEffort`), so it can only ever
+// reach the turn that started it; its promise settles the record and touches
+// nothing else, so an aborted loop is never mutated afterwards. The result
+// lands on the batch's last tool result in one of two places:
+//  - resolved before the next request is projected: on that tool result, so
+//    the request carries it (applyStepEffort);
+//  - resolved later: the request already went out with the earlier effort and
+//    its history is never rewritten (that would break the prompt cache), so
+//    the result marks the last tool result of the next batch, and the
+//    following request carries it (markStepEffort).
+function applyResult(state, target, result) {
+  if (result.level) state.opts.effort = result.level;
+  if (result.marked) target.meta = { ...target.meta, effortConfiguration: result.marked };
+}
+
+// How long a request waits for its step judgment (measured judge p90 ≈ 284 ms).
+export const STEP_EFFORT_GRACE_MS = 300;
+
+/**
+ * Before a provider request is projected: wait up to the grace for the pending
+ * judgment and apply it if it resolved. A slower one leaves this request at
+ * the effort in force and lands on the following request.
+ */
+export async function applyStepEffort(state) {
+  const pending = state.stepEffort;
+  if (!pending || pending.sent) return;
+  if (!pending.settled && !state.signal?.aborted) {
+    let timer;
+    await Promise.race([
+      pending.promise,
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, STEP_EFFORT_GRACE_MS);
+      }),
+    ]);
+    clearTimeout(timer);
+    // Another caller may have handled it while this one waited.
+    if (pending.sent) return;
+  }
+  pending.sent = true;
+  if (!pending.result || state.signal?.aborted || !state.messages.includes(pending.target)) return;
+  applyResult(state, pending.target, pending.result);
+  pending.applied = true;
+}
+
 /**
- * Judge the step after this batch and mark its last tool result.
+ * Start judging the step after this batch (not awaited). The result applies to
+ * the next request if it is ready by then, else to the one after.
  * `state.opts.stepAutoEffort` ({ request, base }) is set only when auto effort
  * is on for this turn and the installed judge was trained on steps.
  */
-export async function markStepEffort(state, assistantTurnMsg) {
+export function markStepEffort(state, assistantTurnMsg) {
   const auto = state.opts?.stepAutoEffort;
   const snapshot = state.opts?.effortConfiguration;
   if (!auto || !snapshot || state.signal?.aborted) return;
@@ -55,11 +102,27 @@ export async function markStepEffort(state, assistantTurnMsg) {
     }
   }
   if (!last) return;
+  const previous = state.stepEffort;
+  if (previous) {
+    // It resolved after its request went out: this batch carries it. One still
+    // running is superseded: the newest step's judgment queues behind it and
+    // any judgment still waiting in between is skipped (latest wins), so the
+    // judge never has more than one running and one queued.
+    if (previous.settled) {
+      if (previous.result && !previous.applied) applyResult(state, last, previous.result);
+    } else {
+      previous.superseded = true;
+    }
+  }
   state.autoEffortSteps = (state.autoEffortSteps || 0) + 1;
   const step = state.autoEffortSteps;
   const provider = state.sessionRef?.provider;
   const model = state.model;
-  const judged = await judgeTurn({
+  const pending = { target: last, sent: false, settled: false, applied: false, superseded: false, result: null };
+  const behind = previous && !previous.settled ? previous.promise : Promise.resolve();
+  state.stepEffort = pending;
+  const context = { auto, snapshot, step, provider, model, providerClient: state.provider, sessionId: state.sessionId };
+  const input = {
     step: {
       request: auto.request,
       step,
@@ -70,11 +133,26 @@ export async function markStepEffort(state, assistantTurnMsg) {
         result: stepResultWindow(textOf(results.get(call.id)?.content)),
       })),
     },
-  });
+  };
+  pending.promise = behind
+    .then(() => (pending.superseded ? null : judgeTurn(input)))
+    .then((judged) => (judged ? stepResult(context, judged) : null))
+    // A failed judgment leaves the step at the effort in force.
+    .catch(() => null)
+    .then((result) => {
+      // Only this record changes here; the loop reads it at its next boundary.
+      pending.result = result;
+      pending.settled = true;
+    });
+}
+
+// What a resolved judgment sets: `{ marked, level }` (the tool result's effort
+// configuration, and the per-request effort of a custom route), or null.
+function stepResult({ auto, snapshot, step, provider, model, providerClient, sessionId }, judged) {
   // `atStep` numbers the tool-result step; `step` in a resolved decision is the ladder move.
   const record = {
     at: new Date().toISOString(),
-    sessionId: state.sessionId,
+    sessionId,
     provider,
     model,
     mode: 'on',
@@ -82,9 +160,9 @@ export async function markStepEffort(state, assistantTurnMsg) {
   };
   if (!judged.probs) {
     recordEffortDecision({ ...record, skipped: judged.skipped });
-    return;
+    return null;
   }
-  const modelMeta = autoEffortModel(provider, state.provider, model);
+  const modelMeta = autoEffortModel(provider, providerClient, model);
   const resolved = resolveAutoEffort({
     base: auto.base,
     options: effortOptionsFor(provider, modelMeta),
@@ -96,19 +174,25 @@ export async function markStepEffort(state, assistantTurnMsg) {
     ms: judged.ms,
     probs: judged.probs.map((value) => Number(value.toFixed(3))),
   });
-  if (snapshot.mode === 'custom') {
+  if (isCustomProviderName(provider)) {
     const level =
       resolved &&
       resolveCustomReasoning({
-        protocol: state.provider?.customConfig?.protocol,
+        protocol: providerClient?.customConfig?.protocol,
         model: modelMeta,
         effort: resolved.effort,
       }).level;
-    if (!level) return;
-    state.opts.effort = level;
-    last.meta = { ...last.meta, effortConfiguration: { ...snapshot, effort: level } };
-    return;
+    if (!level) return null;
+    // The per-request effort also carries the step on an update route,
+    // where a rejected update replays the request with it.
+    return {
+      level,
+      marked:
+        snapshot.mode === 'custom'
+          ? { ...snapshot, effort: level }
+          : stepEffortConfiguration(snapshot, provider, model, level),
+    };
   }
   const marked = resolved && stepEffortConfiguration(snapshot, provider, model, resolved.effort);
-  if (marked) last.meta = { ...last.meta, effortConfiguration: marked };
+  return marked ? { level: null, marked } : null;
 }

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

@@ -70,7 +70,9 @@ export async function runToolPhase(state, round, sent, onToolCall) {
   // carries a runtime notice for the model, delivered after its results.
   if (response.recoveryNotice) messages.push(response.recoveryNotice);
   const toolsEndedAt = Date.now();
-  await markStepEffort(state, assistantTurnMsg);
+  // Starts the step judgment; the next request uses it if it has resolved by
+  // then (send-phase.mjs applyStepEffort), else the one after.
+  markStepEffort(state, assistantTurnMsg);
   try {
     opts.onToolPhaseCompleted?.({
       iteration: round.nextIteration,

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

@@ -54,6 +54,12 @@ export function createAskPromptQueue({ sessionId, promptSource }) {
   // after each turn — keeps queued `agent type=send` messages in order.
   const tail = [];
   let initialPromptSource = initialPromptSourceFor(promptSource);
+  // Queue entries of the input nextTurn handed out that no turn owns yet.
+  // Once a turn starts, its failure path acks or releases them instead.
+  let unstartedEntries = [];
+  const release = (entries) => {
+    if (entries?.length > 0) releasePendingMessages(sessionId, entries);
+  };
 
   /** The next turn's input — prompt, caller context, consumed queue entries
    *  and provenance — or null when nothing model-visible is left to run. */
@@ -83,7 +89,26 @@ export function createAskPromptQueue({ sessionId, promptSource }) {
       tail.unshift(...groups.slice(1).map(tailTurnFor));
       input = queuedTurnInput(tailTurnFor(first));
     }
-    return hasModelVisiblePromptContent(input.prompt) ? input : null;
+    if (!hasModelVisiblePromptContent(input.prompt)) {
+      release(input.pendingEntries);
+      return null;
+    }
+    unstartedEntries = input.pendingEntries;
+    return input;
+  };
+
+  /** The turn for the last nextTurn input started: it now owns its entries. */
+  const markStarted = () => {
+    unstartedEntries = [];
+  };
+
+  /** Hands every drained entry no turn started back to the pending queue —
+   *  the waiting follow-up turns and an input whose turn never opened.
+   *  Called once when the ask unwinds; each entry is released once. */
+  const releaseUnstarted = () => {
+    const entries = [...unstartedEntries, ...tail.splice(0).flatMap((turn) => turn.entries || [])];
+    unstartedEntries = [];
+    release(entries);
   };
 
   /** Queues drained pending-message entries as follow-up turns; true when
@@ -101,5 +126,8 @@ export function createAskPromptQueue({ sessionId, promptSource }) {
     return true;
   };
 
-  return { nextTurn, pushDrained };
+  /** True while drained follow-up turns are still waiting to run. */
+  const hasQueuedTurns = () => tail.length > 0;
+
+  return { nextTurn, pushDrained, hasQueuedTurns, markStarted, releaseUnstarted };
 }

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

@@ -178,6 +178,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         ...claimed,
         ...armTurnDurability({ sessionId, ...claimed, pendingEntries: input.pendingEntries }),
       };
+      // From here the turn's own unwind (ask-turn-failure) acks or releases
+      // its entries; the queue keeps owning only the not-yet-started ones.
+      queue.markStarted();
       const turn = await runAskTurn({
         sessionId,
         opened,
@@ -193,9 +196,12 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
       // that arrived while this turn was in flight runs next, in order, as a
       // follow-up user turn. The mutex is still held, so a send racing this
       // drain either landed before (picked up here) or enqueues for the next
-      // loop. When the queue is empty we return the latest turn's result.
+      // loop. Follow-ups an idle ask already drained wait in the queue's
+      // tail and run before anything new. When both are empty we return the
+      // latest turn's result.
       const drained = turn.drained.length > 0 ? turn.drained : drainPendingMessages(sessionId);
-      if (queue.pushDrained(drained)) {
+      queue.pushDrained(drained);
+      if (queue.hasQueuedTurns()) {
         // Carry the just-committed in-memory session into the follow-up
         // turn so the queued tail sees the preceding assistant/tool
         // context. loadSession() would return this same live snapshot
@@ -216,6 +222,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
       return result;
     }
   } finally {
+    // A failed/cancelled turn ends the ask: the follow-up turns drained
+    // behind it never ran, so their entries go back to the pending queue.
+    queue.releaseUnstarted();
     // A thrown setup/provider path must never leave a delayed checkpoint
     // writer alive after the turn lock is released.
     // Clear the controller only if it's still ours (closeSession may have

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

@@ -27,16 +27,12 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // Register the live session object for synchronous close snapshots.
   runtime.session = session;
   if (!provider) throw new Error(`Provider "${session.provider}" not available`);
-  const autoEffort = await resolveTurnAutoEffort({ sessionId, session, provider, input });
-  const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
-  const effortConfiguration = prepareTurnEffortConfiguration(
-    session,
-    provider,
-    autoEffort?.applied ? autoEffort.effort : undefined
-  );
-  // Auto effort also judges every tool-result step of the turn when the
-  // installed judge was trained on steps (session/loop/step-auto-effort.mjs).
-  const stepAutoEffort = turnStepAutoEffort(autoEffort, effortConfiguration);
+  // The turn-level judgment runs while the rest of the turn is prepared; it
+  // reads the session as the turn found it (synchronously, on this call).
+  // The first request still carries its decision: it is awaited below,
+  // together with the user turn, before the effort configuration is stamped.
+  const autoEffortPending = resolveTurnAutoEffort({ sessionId, session, provider, input });
+  autoEffortPending.catch(() => {});
   applyTurnContextMeta(session, provider);
   const effectiveCwd = cwdOverride || session.cwd;
   // A failed-turn retry resubmits the prompt the failure left unanswered;
@@ -46,25 +42,49 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   if (session.sessionStartMetaInjected !== true && !hasUserConversationMessage(session.messages)) {
     refreshSessionBp3Environment(session, effectiveCwd);
   }
+  // The prewarm only opens the transport (effort never shapes the socket), so
+  // it starts now instead of after the judgment.
   const startupProviderPrewarm = startProviderPrewarm({
     sessionId,
     session,
     provider,
-    turnEffort,
-    effortConfiguration,
+    turnEffort: session.effort || null,
+    effortConfiguration: null,
     codexTurnId,
     startedAtMs: startedAt,
   });
-  const userTurn = await buildUserTurn({
+  const [autoEffort, userTurn] = await Promise.all([
+    autoEffortPending,
+    buildUserTurn({
+      session,
+      prompt: input.prompt,
+      context: input.context,
+      explicitPrefetch: input.explicitPrefetch,
+      turnSignal,
+      transcriptMeta,
+      turnPromptSource: input.promptSource,
+      effortConfiguration: null,
+    }),
+  ]);
+  const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
+  const effortConfiguration = prepareTurnEffortConfiguration(
     session,
-    prompt: input.prompt,
-    context: input.context,
-    explicitPrefetch: input.explicitPrefetch,
-    turnSignal,
-    transcriptMeta,
-    turnPromptSource: input.promptSource,
-    effortConfiguration,
-  });
+    provider,
+    autoEffort?.applied ? autoEffort.effort : undefined
+  );
+  // Auto effort also judges every tool-result step of the turn when the
+  // installed judge was trained on steps (session/loop/step-auto-effort.mjs).
+  const stepAutoEffort = turnStepAutoEffort(autoEffort, effortConfiguration);
+  if (effortConfiguration) {
+    // Stamp the turn's effort on the user message (same meta order as when it
+    // was built with it: before the runtime-context provenance).
+    const { runtimeUserContext, ...meta } = userTurn.userTurnMessage.meta || {};
+    userTurn.userTurnMessage.meta = {
+      ...meta,
+      effortConfiguration,
+      ...(runtimeUserContext ? { runtimeUserContext } : {}),
+    };
+  }
   const { historyMessages, outgoing } = userTurn;
   turn.userTurnContent = userTurn.userTurnMessage.content;
   turn.outgoing = outgoing;

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

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { mergeNormalizedContentEntries } from '../loop/steering.mjs';
 import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions.mjs';
-import { isInternalRuntimeNotificationText, promptContentText } from './prompt-utils.mjs';
+import { promptContentText } from './prompt-utils.mjs';
 import { parseTaskNotification, taskNotificationId } from '../../../../shared/task-notification-envelope.mjs';
 
 const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
@@ -295,15 +295,10 @@ function normalizePersistedEntryBase(entry) {
 }
 
 export function modelVisiblePendingMessages(messages) {
-  return (Array.isArray(messages) ? messages : [])
-    .map(pendingMessageQueueEntry)
-    .filter(Boolean)
-    .filter(
-      (message) =>
-        !isInternalRuntimeNotificationText(
-          message && typeof message === 'object' && Object.hasOwn(message, 'content') ? message.content : message
-        )
-    );
+  // No content filter: isInternalRuntimeNotificationText is a display-only
+  // predicate. Every canonical completion envelope matches it, and a drained
+  // entry the model never sees is never claimed/acked/released.
+  return (Array.isArray(messages) ? messages : []).map(pendingMessageQueueEntry).filter(Boolean);
 }
 
 export function _mergePendingMessageEntries(entries) {

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

@@ -216,7 +216,7 @@ function releaseSessionReadCaches(id) {
     /* ignore */
   }
   try {
-    forgetSessionSaveBaseline(id);
+    forgetSessionSaveBaseline(id, { releaseWriteControl: true });
   } catch {
     /* ignore */
   }

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

@@ -1,6 +1,6 @@
 import { sanitizeToolPairs } from '../context-utils.mjs';
 import { collectAssistantToolCallIds as assistantToolCallIds } from '../context-tool-pairs.mjs';
-import { isInternalRuntimeNotificationText, promptContentText } from './prompt-utils.mjs';
+import { promptContentText } from './prompt-utils.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
 import { journalDelta } from './turn-interruption-journal.mjs';
 
@@ -72,8 +72,11 @@ function finalizeInterruptedTurn({
       const index = provisionalUserTurnIndex(messages, currentUserContent);
       return index >= 0 && index < messages.length - 1;
     })();
-  const preserveResponse =
-    responseStarted && !isInternalRuntimeNotificationText(currentUserContent) && (producedOutput || !userCancelled);
+  // A turn woken by a task notification is preserved by the same rule as a
+  // user prompt: once it produced output its notification is consumed (the
+  // host commits it and never requeues it), so rewinding it would erase the
+  // turn and its side effects from history.
+  const preserveResponse = responseStarted && (producedOutput || !userCancelled);
   if (!preserveResponse) {
     if (!userCancelled) {
       return {
@@ -198,8 +201,11 @@ export function createTurnInterruptionTracker() {
       // copies of the same first sentence). Reference agents never
       // commit a replayed attempt's discarded stream at all; the
       // tombstone exists only for the window between a retraction and
-      // its replacement.
-      if (state.tombstonedAssistantContent) {
+      // its replacement. Whitespace is not a replacement: it is not output
+      // (finalizeInterruptedTurn trims, and the host commits the prompt only
+      // on non-blank text), so until real text arrives the retracted bytes
+      // remain the only output the user saw.
+      if (state.tombstonedAssistantContent && value.trim()) {
         state.tombstonedAssistantContent = '';
         state.tombEpoch += 1;
       }
@@ -212,8 +218,13 @@ export function createTurnInterruptionTracker() {
       // REPLACE, never accumulate: consecutive retractions belong to
       // successive attempts at the SAME answer, so keeping the earlier
       // tombstone alongside the newer one is what multiplied the visible
-      // text across retries.
-      state.tombstonedAssistantContent = state.partialAssistantContent.slice(cutAt);
+      // text across retries. A whitespace-only retraction is not a newer
+      // attempt at the answer (recordTextDelta never let it supersede the
+      // draft), so it never replaces a meaningful tombstone.
+      const retracted = state.partialAssistantContent.slice(cutAt);
+      if (retracted.trim() || !state.tombstonedAssistantContent.trim()) {
+        state.tombstonedAssistantContent = retracted;
+      }
       state.partialAssistantContent = state.partialAssistantContent.slice(0, cutAt);
       state.textEpoch += 1;
       state.tombEpoch += 1;