mixdog 1.2.1 → 1.2.3

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-auto-effort.mjs

@@ -15,7 +15,7 @@ import {
   resolveAutoEffort,
 } from '../../providers/auto-effort.mjs';
 import { builtinFeatureActive } from '../../runtime-core/builtin-features.mjs';
-import { effortOptionsFor } from '../../runtime-core/effort.mjs';
+import { effortOptionsFor, warnEmptyAutoEffortLadder } from '../../runtime-core/effort.mjs';
 import { effortJudgeSupportsSteps, judgeTurn, recordEffortDecision } from '../../../../effort-judge/judge-client.mjs';
 import { promptContentText } from './prompt-utils.mjs';
 
@@ -98,6 +98,7 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
   // the judge is not asked (in observe mode too: nothing would be logged).
   if (!autoEffortApplicable({ base, options })) {
     recordEffortDecision({ ...record, skipped: 'default-outside-auto-range' });
+    warnEmptyAutoEffortLadder(session.provider, session.model, base);
     return null;
   }
   // The previous user request shows the work a short follow-up continues.

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

@@ -120,22 +120,44 @@ function recordAgentRuntimeCall(session, result) {
 export async function recordAskUsage({ session, result, askStartedAt, turnSignal }) {
   const prefixHashForLog = recordAgentRuntimeCall(session, result);
   if (!result.usage) return;
-  const inputTokens = result.usage.inputTokens || 0;
-  const outputTokens = result.usage.outputTokens || 0;
-  const cacheReadTokens = result.usage.cachedTokens || 0;
-  const cacheWriteTokens = result.usage.cacheWriteTokens || 0;
+  await logSessionLlmUsage({
+    session,
+    usage: result.usage,
+    startedAt: askStartedAt,
+    signal: turnSignal,
+    prefixHash: prefixHashForLog,
+    transportTiming: result.transportTiming || null,
+  });
+  recordStandaloneStatusTelemetry(session, result, Date.now() - askStartedAt);
+}
+
+/** The usage-ledger row of one provider call billed to `session`. `mode`
+ *  labels a call made outside the turn loop (a /btw side question). */
+export async function logSessionLlmUsage({
+  session,
+  usage,
+  startedAt,
+  signal = null,
+  prefixHash = null,
+  transportTiming = null,
+  mode = null,
+}) {
+  const inputTokens = usage.inputTokens || 0;
+  const outputTokens = usage.outputTokens || 0;
+  const cacheReadTokens = usage.cachedTokens || 0;
+  const cacheWriteTokens = usage.cacheWriteTokens || 0;
   // Unified total-prompt field. Anthropic = input+cache_read+cache_write
   // (additive); OpenAI OAuth/API/Gemini = input_tokens already includes the
   // cached portion (inclusive), so the fallback must not double-count.
   const { isInclusiveProvider, computeCostUsd } = await runAbortable(
-    turnSignal,
+    signal,
     () => import('../../../../shared/llm/cost.mjs')
   );
   const inclusive = isInclusiveProvider(session.provider);
   let promptTokens = inputTokens + cacheReadTokens + cacheWriteTokens;
-  if (typeof result.usage.promptTokens === 'number') promptTokens = result.usage.promptTokens;
+  if (typeof usage.promptTokens === 'number') promptTokens = usage.promptTokens;
   else if (inclusive) promptTokens = Math.max(inputTokens, cacheReadTokens + cacheWriteTokens);
-  let costUsd = result.usage.costUsd || 0;
+  let costUsd = usage.costUsd || 0;
   if (!costUsd) {
     try {
       costUsd = computeCostUsd({
@@ -145,7 +167,7 @@ export async function recordAskUsage({ session, result, askStartedAt, turnSignal
         outputTokens,
         cacheReadTokens,
         cacheWriteTokens,
-        cacheWrite1hTokens: result.usage.cacheWrite1hTokens || 0,
+        cacheWrite1hTokens: usage.cacheWrite1hTokens || 0,
       });
     } catch {
       /* best-effort */
@@ -158,7 +180,8 @@ export async function recordAskUsage({ session, result, askStartedAt, turnSignal
     preset: session.presetName || null,
     model: session.model,
     provider: session.provider,
-    duration: Date.now() - askStartedAt,
+    ...(mode ? { mode } : {}),
+    duration: Date.now() - startedAt,
     profileId: session.profileId || null,
     sessionId: session.id,
     inputTokens,
@@ -166,11 +189,10 @@ export async function recordAskUsage({ session, result, askStartedAt, turnSignal
     cacheReadTokens,
     cacheWriteTokens,
     promptTokens,
-    prefixHash: prefixHashForLog,
+    prefixHash,
     costUsd,
-    transportTiming: result.transportTiming || null,
+    transportTiming,
   });
-  recordStandaloneStatusTelemetry(session, result, Date.now() - askStartedAt);
 }
 
 /** Persist opaque providerState for stateful providers. The update bit

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

@@ -5,6 +5,7 @@
 // (runAskAgentLoop). Provider-not-available and trim failures throw here so
 // the caller marks the session errored instead of leaving stage='connecting'.
 import { getProvider } from '../../providers/registry.mjs';
+import { pinSessionWireRoute } from '../../providers/wire-route.mjs';
 import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import { resolveTurnAutoEffort, turnStepAutoEffort } from './ask-turn-auto-effort.mjs';
@@ -17,6 +18,7 @@ import { applyTurnContextMeta, buildUserTurn, startProviderPrewarm, traceTurnCon
 import { rewindUnansweredPrompt } from './failed-turn-rewind.mjs';
 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';
 
 /** Resolves the provider, builds the user turn and pre-commits it; returns
  *  what the loop and the commit need from this preparation. */
@@ -27,16 +29,16 @@ 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 session's wire is pinned before its first request (an existing
+  // session keeps the wire it started on); read from the history as the turn
+  // found it, awaited with the user turn below.
+  const wireRoutePending = pinSessionWireRoute(session, provider);
+  // 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 +48,50 @@ 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,
+    }),
+    wireRoutePending,
+  ]);
+  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;
@@ -87,6 +114,14 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // user turn is introduced.
   session.messages = filterModelVisibleSessionMessages(outgoing);
   session.liveTurnMessages = outgoing;
+  // Name a titleless session from its first human prompt before the first
+  // save, so the title outlives any later compaction of the transcript. The
+  // earliest human turn already in the history wins; this turn's prompt is the
+  // fallback (runtime-injected turns carrying a promptSource never name it).
+  backfillFallbackSessionTitle(session, [
+    ...historyMessages,
+    ...(input.promptSource ? [] : [{ role: 'user', content: input.prompt }]),
+  ]);
   session.activeTurnCheckpoint = {
     version: 1,
     turnToken,
@@ -127,6 +162,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
     beforeCount: historyMessages.length + 1,
     deferredToolDelta: userTurn.deferredToolDelta,
     goalReminder: userTurn.goalReminder,
+    workspaceNotice: userTurn.workspaceNotice,
   };
 }
 

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

@@ -18,6 +18,53 @@ const relay = (fn, ...args) => {
   }
 };
 
+/**
+ * The callback-free send options that shape a turn's provider request (effort,
+ * model parameters, cache routing, continuation state, Codex wire identity and
+ * the session's provider cache settings). agentLoop's options spread them, and
+ * a /btw request built before any turn has run uses them as they are.
+ */
+export function buildRequestSendOptions({
+  sessionId,
+  session,
+  turnEffort,
+  effortConfiguration,
+  stepAutoEffort,
+  codexTurnId,
+  startedAtMs,
+  signal,
+}) {
+  return {
+    effort: turnEffort,
+    effortConfiguration,
+    // { request, base } when each tool-result step is judged (step-auto-effort.mjs).
+    stepAutoEffort: stepAutoEffort || null,
+    fast: session.fast === true,
+    modelParameters: session.modelParameters || {},
+    selectedContextWindow: session.selectedContextWindow || session.contextWindow || null,
+    sessionId,
+    // Same projection compaction uses, so a session presents one identity on
+    // every request it makes.
+    ...(codexWireSendOpts(session, { turnId: codexTurnId, startedAtMs }) || {}),
+    promptCacheKey: session.promptCacheKey || sessionId,
+    // Provider-scoped cache key (mixdog-codex, mixdog-claude…). Distinct
+    // from sessionId — providers that pool sockets per-session (openai-oauth
+    // WS) use sessionId as the pool bucket and providerCacheKey as the
+    // server-side prompt-cache shard so parallel callers don't collide on a
+    // mid-turn socket while still sharing prefix cache.
+    providerCacheKey: session.promptCacheKey || null,
+    signal,
+    providerState: session.providerState ?? undefined,
+    // The wire this session is pinned to (wire-route.mjs).
+    wireRoute: session.wireRoute ?? undefined,
+    session,
+    // Agent Runtime cache settings — merged last so session overrides don't
+    // get overridden by defaults. When session has no profile,
+    // providerCacheOpts is null and this spread is a no-op.
+    ...(session.providerCacheOpts || {}),
+  };
+}
+
 /**
  * @param {object} input
  * @param {string} input.sessionId
@@ -49,14 +96,6 @@ export function buildAgentLoopOptions({
   // (ask-turn-steering-drain.mjs).
   const drainSteering = createAskSteeringDrain({ sessionId, turn, askOpts });
   return {
-    effort: turnEffort,
-    effortConfiguration,
-    // { request, base } when each tool-result step is judged (step-auto-effort.mjs).
-    stepAutoEffort: stepAutoEffort || null,
-    fast: session.fast === true,
-    modelParameters: session.modelParameters || {},
-    selectedContextWindow: session.selectedContextWindow || session.contextWindow || null,
-    sessionId,
     onTextDelta: (chunk) => {
       interruption.recordTextDelta(chunk);
       checkpoint.schedule();
@@ -157,23 +196,16 @@ export function buildAgentLoopOptions({
       relay(askOpts?.onSkillsApplied, names, detail);
     },
     notifyFn: optionalFn(askOpts?.notifyFn),
-    // Same projection compaction uses, so a session presents one identity on
-    // every request it makes.
-    ...(codexWireSendOpts(session, { turnId: codexTurnId, startedAtMs }) || {}),
-    promptCacheKey: session.promptCacheKey || sessionId,
-    // Provider-scoped cache key (mixdog-codex, mixdog-claude…). Distinct
-    // from sessionId — providers that pool sockets per-session (openai-oauth
-    // WS) use sessionId as the pool bucket and providerCacheKey as the
-    // server-side prompt-cache shard so parallel callers don't collide on a
-    // mid-turn socket while still sharing prefix cache.
-    providerCacheKey: session.promptCacheKey || null,
-    signal,
-    providerState: session.providerState ?? undefined,
-    session,
-    // Agent Runtime cache settings — merged last so session overrides don't
-    // get overridden by defaults. When session has no profile,
-    // providerCacheOpts is null and this spread is a no-op.
-    ...(session.providerCacheOpts || {}),
+    ...buildRequestSendOptions({
+      sessionId,
+      session,
+      turnEffort,
+      effortConfiguration,
+      stepAutoEffort,
+      codexTurnId,
+      startedAtMs,
+      signal,
+    }),
     onStageChange: (stage, detail) => {
       updateSessionStage(sessionId, stage);
       relay(askOpts?.onStageChange, stage, detail);

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

@@ -16,6 +16,7 @@ import {
   prefixUserTurnContent,
   suffixUserTurnReminders,
   buildCurrentTimeBlock,
+  snapshotPendingWorkspaceNotice,
 } from './prompt-utils.mjs';
 import { codexWireSendOpts } from './session-id.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
@@ -173,7 +174,11 @@ export async function buildUserTurn({
   // input intake: either can precede the previous turn's pause.
   // This supplies context only; it never resumes the Goal.
   const goalReminder = snapshotPendingGoalReminder(session, { includePaused: true });
+  // A mid-conversation working-folder change: the system prompt keeps its
+  // old root (cache intact) and the new folder's facts ride this turn.
+  const workspaceNotice = snapshotPendingWorkspaceNotice(session);
   const reminderBlock = [
+    workspaceNotice?.content || '',
     currentTimeBlock ? `<system-reminder>\n# Current Time\n${currentTimeBlock}\n</system-reminder>` : '',
     deferredToolDelta?.content || '',
     goalReminder?.content || '',
@@ -200,6 +205,7 @@ export async function buildUserTurn({
     historyMessages,
     deferredToolDelta,
     goalReminder,
+    workspaceNotice,
     userTurnMessage,
     outgoing: [...historyMessages, userTurnMessage],
   };

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

@@ -8,6 +8,7 @@ import { ingestSessionTurn } from '../../../../session-search/session-search-ing
 import { persistedAssistantTranscriptMetadata } from '../../../../shared/transcript-metadata.mjs';
 import { acknowledgePendingDeferredToolDelta } from '../../runtime-core/deferred-tool-delta.mjs';
 import { acknowledgePendingGoalReminder } from '../../runtime-core/goal-reminder.mjs';
+import { acknowledgePendingWorkspaceNotice } from './prompt-utils.mjs';
 import {
   finalizePendingMessageDelivery,
   drainPendingMessages,
@@ -121,6 +122,9 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
   if (prepared.goalReminder) {
     acknowledgePendingGoalReminder(session, prepared.goalReminder.revision);
   }
+  if (prepared.workspaceNotice) {
+    acknowledgePendingWorkspaceNotice(session, prepared.workspaceNotice.revision);
+  }
   return {
     ...result,
     trimmed: messagesDropped > 0,

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

@@ -21,7 +21,9 @@ import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
 import { _getPendingMessagesForSession } from './pending-messages.mjs';
 import { isSessionCompactionBlocked } from './runtime-liveness.mjs';
+import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
 import { resetReadStateAfterCompaction } from '../read-dedup.mjs';
+import { applyPendingWorkspaceReroot } from './prompt-utils.mjs';
 import {
   compactTargetBudget as compactTargetBudgetForPolicy,
   compactDisplayBeforeTokens,
@@ -629,7 +631,13 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
   let unchangedReason = null;
   if (!changed) unchangedReason = force ? 'nothing to compact' : 'below threshold';
   const now = Date.now();
+  // Older titleless sessions: keep a name before the transcript that carries
+  // the first prompt is replaced.
+  if (changed) backfillFallbackSessionTitle(session, messages);
   session.messages = transcript;
+  // The compacted transcript breaks the cache anyway: a staged working-folder
+  // change re-roots the system prompt now and needs no notice any more.
+  if (changed) applyPendingWorkspaceReroot(session);
   if (changed) resetReadStateAfterCompaction(resolvedSessionId);
   await pruneCompactedOffloads(session, resolvedSessionId);
   if (changed) session.providerState = undefined;

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) {