mixdog 1.2.1 → 1.2.3

package/src/session-runtime/turn/session-ops.mjs

@@ -10,7 +10,6 @@ export function createSessionOps(deps) {
   const {
     getSession,
     setSession,
-    getCurrentCwd,
     setMode,
     getActiveTurnCount,
     mgr,
@@ -18,7 +17,7 @@ export function createSessionOps(deps) {
     agentTool,
     invalidatePreSessionToolSurface,
     refreshEmptySessionToolPolicy,
-    applyResolvedCwd,
+    switchProject,
     resolveCwdPath,
     agentStatusState,
     getReservedSessionId,
@@ -122,9 +121,12 @@ export function createSessionOps(deps) {
     return { messageCount: list.length, messages: list.slice(start) };
   }
 
-  function setCwd(path) {
-    applyResolvedCwd(resolveCwdPath(path), { persistProjectSelection: true });
-    return getCurrentCwd();
+  // The desktop/remote Project switch: refused while a turn runs or the
+  // session works in a managed worktree (switchProject); resolves once the
+  // prompt refresh landed. Its target is a registered Project or the task
+  // workspace, classified by desktop membership.
+  async function setCwd(path) {
+    return switchProject(resolveCwdPath(path), { classifyByMembership: true });
   }
 
   return {

package/src/session-runtime/turn/side-question-ops.mjs

@@ -0,0 +1,22 @@
+/**
+ * src/session-runtime/turn/side-question-ops.mjs - /btw side questions on the
+ * runtime's current session. They run beside an in-progress turn and touch no
+ * session state (see orchestrator/session/side-question.mjs).
+ */
+import {
+  askSideQuestion,
+  cancelSideQuestion,
+} from '../../runtime/agent/orchestrator/session/side-question.mjs';
+
+export function createSideQuestionOps({ getSession, getReservedSessionId }) {
+  const sessionId = () => getSession()?.id || getReservedSessionId?.() || '';
+  return {
+    /** @returns {Promise<{ text: string }>} */
+    askSide: (question) => askSideQuestion(sessionId(), question),
+    /** Abort the side question of `targetSessionId` (the session it was
+     *  asked in), or of the current session when omitted. */
+    cancelSide: (targetSessionId) => {
+      cancelSideQuestion(typeof targetSessionId === 'string' && targetSessionId ? targetSessionId : sessionId());
+    },
+  };
+}

package/src/session-runtime/turn/turn-run/ask-callbacks.mjs

@@ -1,4 +1,5 @@
 import { isVisibleStreamProgress } from '../../../runtime/shared/stream-progress.mjs';
+import { toolCallDisplayIdentity } from '../../../runtime/shared/tool-primitives.mjs';
 
 // The askSession callback bridge: caller callbacks pass through, with the
 // transcript, first-visible timing, title release and warmup arming folded in.
@@ -6,10 +7,13 @@ export function createAskCallbacks({ transcript, notifyFnForSession, scheduleSea
   function plannedToolCalls(session0, options) {
     return async (iter, calls) => {
       for (const call of calls || []) {
+        // A bridged call reports the tool it runs; the transcript keeps the wire call.
+        const identity = toolCallDisplayIdentity(call?.name, call?.arguments);
         hooks.emit('tool:planned', {
           sessionId: session0.id,
-          name: call?.name || 'tool',
+          name: identity.name || 'tool',
           callId: call?.id || null,
+          ...(identity.via ? { via: identity.via } : {}),
         });
       }
       if (typeof options.onToolCall === 'function') {

package/src/session-runtime/turn/turn-run/turn-prepare.mjs

@@ -49,9 +49,9 @@ export function createTurnPreparation({
     // Slower servers remain available through the late-tool path; a reconnect
     // in flight gets the same short TTFT grace BEFORE folding the catalog so it
     // cannot hold the provider request. No reconnect in flight → no-op.
-    const awaitGrace = async () => {
+    const awaitGrace = async (options) => {
       try {
-        await turn.awaitTurn(() => turn.timing.awaitMcpGrace());
+        await turn.awaitTurn(() => turn.timing.awaitMcpGrace(options));
       } catch {
         /* gate must never break the turn */
       }
@@ -64,7 +64,12 @@ export function createTurnPreparation({
       // One-shot: cleared before the fold so a throw still never re-runs it,
       // and a resumed session (flag unset) skips straight to the late path.
       session0.deferredInitialRefreshPending = false;
-      await awaitGrace();
+      // A spawned agent runtime owns a fresh MCP scope whose connect starts at
+      // its boot, so the 0 ms default grace would hide every MCP tool from the
+      // agent's first (often only) turn. Agents are not on the user's TTFT
+      // path: wait for the initial connect within the server startup budget.
+      const agentOwned = session0.owner === 'agent' || session0.visibility === 'agent-only';
+      await awaitGrace({ untilConnected: agentOwned });
       try {
         refreshInitialDeferredMcpSurface(session0, scopedMcpTools(session0));
       } catch {

package/src/session-runtime/turn/turn-run/turn-settle.mjs

@@ -28,6 +28,8 @@ export function createTurnSettlement({
   setFirstTurnCompleted,
   scheduleProviderWarmup,
   scheduleProviderModelWarmup,
+  takePendingCompact,
+  runPendingCompact,
 }) {
   async function completeTurn(turn, session0, result) {
     throwIfAborted(turn.signal);
@@ -99,6 +101,14 @@ export function createTurnSettlement({
       /* lead pool must never break turn teardown */
     }
     setActiveTurnCount(Math.max(0, getActiveTurnCount() - 1));
+    // A compaction the model scheduled (session tool) runs once the turn is over.
+    // Only while the settled session is still the live one; otherwise it stays
+    // pending for that session and never compacts another. The runner chains
+    // the compaction so the next turn waits on it.
+    const settledId = turn.session0?.id;
+    if (getActiveTurnCount() === 0 && settledId && getSession()?.id === settledId && takePendingCompact?.(settledId)) {
+      runPendingCompact?.(settledId);
+    }
     if (!isFirstTurnCompleted()) {
       setFirstTurnCompleted(true);
       scheduleProviderWarmup();

package/src/session-runtime/turn/turn-run/turn-timing.mjs

@@ -38,11 +38,12 @@ export function createTurnTimingFactory({ getSession, awaitInitialMcpConnect, mc
         /* timing telemetry must never affect a turn */
       }
     };
-    // Give an in-flight MCP connect only a short TTFT grace.
-    timing.awaitMcpGrace = async () => {
+    // Give an in-flight MCP connect only a short TTFT grace. untilConnected
+    // waits for the initial connect bounded only by the server startup budget.
+    timing.awaitMcpGrace = async ({ untilConnected = false } = {}) => {
       const graceStartedAt = performance.now();
       try {
-        await awaitInitialMcpConnect?.(mcpTurnGraceMs);
+        await awaitInitialMcpConnect?.(untilConnected ? undefined : mcpTurnGraceMs);
       } finally {
         timing.mcpWaitMs += performance.now() - graceStartedAt;
       }

package/src/session-runtime/turn/turn-run.mjs

@@ -13,6 +13,7 @@ import { createSnapshotTrackerFactory } from './turn-run/snapshot-tracker.mjs';
 import { createTurnOpener } from './turn-run/turn-open.mjs';
 import { createTurnPreparation } from './turn-run/turn-prepare.mjs';
 import { createAskCallbacks } from './turn-run/ask-callbacks.mjs';
+import { registerNativeWebSearchUsageSink } from '../native-web-search-usage.mjs';
 import { createTurnSettlement } from './turn-run/turn-settle.mjs';
 
 export function createTurnRunner(deps) {
@@ -94,15 +95,30 @@ export function createTurnRunner(deps) {
     try {
       const session0 = await prepareSession(turn, prompt, options);
       const turnContext = await dispatchPromptSubmit(turn, session0, prompt, options);
-      const result = await mgr.askSession(
-        session0.id,
-        prompt,
-        turnContext || null,
-        plannedToolCalls(session0, options),
-        getCurrentCwd(),
-        options.prefetch || null,
-        askCallbacks(turn, session0, options)
-      );
+      const callbacks = askCallbacks(turn, session0, options);
+      // Register only once askSession's session lock is held: the first
+      // provider send of this turn. A turn queued behind another on the same
+      // session id therefore never receives the running turn's search usage.
+      let releaseWebSearchUsage = null;
+      const providerSendStarted = callbacks.onProviderSendStarted;
+      callbacks.onProviderSendStarted = (...args) => {
+        releaseWebSearchUsage ??= registerNativeWebSearchUsageSink(session0.id, options.onNativeWebSearchUsage);
+        return providerSendStarted(...args);
+      };
+      let result;
+      try {
+        result = await mgr.askSession(
+          session0.id,
+          prompt,
+          turnContext || null,
+          plannedToolCalls(session0, options),
+          getCurrentCwd(),
+          options.prefetch || null,
+          callbacks
+        );
+      } finally {
+        releaseWebSearchUsage?.();
+      }
       return await completeTurn(turn, session0, result);
     } catch (error) {
       reportTurnError(turn, error);

package/src/session-runtime/usage-stats-api.mjs

@@ -82,22 +82,43 @@ function accountsInUse(accountPool) {
   return inUse;
 }
 
-// Every id a session's spend was recorded under: its own, and the per-account
-// provider session each subscription account sent it under before account
-// sends recorded the visible session.
-function sessionUsageIds(sessionId, accountPool) {
-  const ids = [sessionId];
+// Each subscription provider's account ids, read once per request.
+function accountScopes(accountPool) {
+  const scopes = [];
   for (const provider of ACCOUNT_PROVIDERS) {
     try {
-      for (const account of accountPool(provider).accounts)
-        ids.push(accountScopedSessionId(provider, account.id, sessionId));
+      scopes.push([provider, accountPool(provider).accounts.map((account) => account.id)]);
     } catch {
       /* an unreadable pool leaves that provider's older records out */
     }
   }
+  return scopes;
+}
+
+// Every id a session's spend was recorded under: its own, and the per-account
+// provider session each subscription account sent it under before account
+// sends recorded the visible session.
+function sessionUsageIdsFor(scopes, sessionId) {
+  const ids = [sessionId];
+  for (const [provider, accounts] of scopes) {
+    for (const account of accounts) ids.push(accountScopedSessionId(provider, account, sessionId));
+  }
   return ids;
 }
 
+// Other sessions a caller asks about beside its own (the composer island's
+// agent sessions): bounded, distinct, never the caller's own id.
+const MAX_SESSION_USAGE_IDS = 64;
+function otherSessionIds(options, sessionId) {
+  const ids = Array.isArray(options?.sessionIds) ? options.sessionIds : [];
+  const unique = new Set();
+  for (const id of ids) {
+    if (typeof id === 'string' && id && id !== sessionId) unique.add(id);
+    if (unique.size >= MAX_SESSION_USAGE_IDS) break;
+  }
+  return [...unique];
+}
+
 /** `null` = all time. `0` = today. Anything else is a trailing day count. */
 function normalizeDays(value) {
   if (value === null || value === undefined || value === 'all') return null;
@@ -213,15 +234,26 @@ export function createUsageStatsApi({
       return snapshot;
     },
 
-    /** This runtime's session from its first request, compactions included; null before it has one. */
-    async getSessionUsage() {
+    /**
+     * This runtime's session from its first request, compactions included; null before it has one.
+     * `sessionIds` adds the same totals for each named session (the agents it spawned) under
+     * `sessions`, each read by its own id only.
+     */
+    async getSessionUsage(options = {}) {
       const sessionId = getSessionId();
       if (!sessionId) return null;
       const store = ledger();
       if (!store) throw new Error('Usage ledger is unavailable');
       await store.settleWrites();
-      const usage = await store.sessionUsageAsync(sessionUsageIds(sessionId, accountPool));
-      return { sessionId, ...sessionUsageSnapshot(usage) };
+      const scopes = accountScopes(accountPool);
+      const usage = await store.sessionUsageAsync(sessionUsageIdsFor(scopes, sessionId));
+      const result = { sessionId, ...sessionUsageSnapshot(usage) };
+      const others = otherSessionIds(options, sessionId);
+      if (!others.length) return result;
+      const totals = await Promise.all(
+        others.map(async (id) => [id, sessionUsageSnapshot(await store.sessionUsageAsync(sessionUsageIdsFor(scopes, id)))])
+      );
+      return { ...result, sessions: Object.fromEntries(totals) };
     },
 
     /**

package/src/session-runtime/workspace/project-branches.mjs

@@ -54,12 +54,14 @@ export function createProjectBranchOps({ backend, inspectProject, findRegistered
     const path = await registeredProject(projectPath);
     const project = await inspectProject(path);
     const menu = await (await backend()).listBranchOccupancy({ projectPath: path, sessionId: null });
+    const workspace = projectWorkspace({
+      projectPath: path,
+      repoCommonDir: project.repoCommonDir,
+      branch: project.currentBranch,
+    });
     return {
-      workspace: projectWorkspace({
-        projectPath: path,
-        repoCommonDir: project.repoCommonDir,
-        branch: project.currentBranch,
-      }),
+      // Detached: branch null and the checked-out commit in baseCommit.
+      workspace: project.currentBranch ? workspace : { ...workspace, baseCommit: project.headCommit ?? null },
       branches: branchMenuEntries(menu.branches, menu.occupancy),
       occupancy: menu.occupancy,
       retainedWorktree: null,

package/src/session-runtime/workspace/transition-steps.mjs

@@ -18,7 +18,9 @@ import { checkoutFolder, projectSubdirOf, samePath } from '../../runtime/shared/
 import { setWorkspaceCwdLock, workspaceCwdLock } from './admission-gate.mjs';
 import { copyProjectIdentity } from './workspace-state.mjs';
 
-const PROMPT_FIELDS = ['bp3EnvironmentContext', 'bp3CoreContext', 'sessionStartMetaInjected'];
+// workspaceReroot: the staged working-folder change and its pending notice
+// (prompt-utils stageWorkspaceReroot); a rollback drops the notice with it.
+const PROMPT_FIELDS = ['bp3EnvironmentContext', 'bp3CoreContext', 'sessionStartMetaInjected', 'workspaceReroot'];
 
 /** Everything a prompt refresh rewrites on `target`, restorable exactly. */
 function snapshotPrompt(target) {
@@ -90,6 +92,8 @@ export function createTransitionSteps({
   inspectProject,
   runtimeToken,
   getCurrentCwd,
+  getDesktopSession,
+  setDesktopSession,
   applyResolvedCwd,
   persistSession,
   refreshWorkspaceContext,
@@ -97,11 +101,19 @@ export function createTransitionSteps({
   updateLeadWorkerCwd,
   workersOf,
   withProjectFolder,
+  assertCheckoutQuiet = async () => {},
 }) {
   const owner = (sessionId) => ({ sessionId, runtimeToken, pid: process.pid });
+  const moveLeadRow = (sessionId, cwd) => {
+    try {
+      updateLeadWorkerCwd(sessionId, cwd);
+    } catch {
+      /* the Lead pool must never break a transition */
+    }
+  };
 
   /** Point this Lead's idle workers at the new root so a reused worker never keeps an old workspace. */
-  async function retargetWorkers(session, cwd, journal) {
+  async function retargetWorkers(session, cwd, journal, move = null) {
     for (const worker of workersOf(session)) {
       if (samePath(worker.cwd || '', cwd)) continue;
       const priorCwd = worker.cwd;
@@ -113,7 +125,7 @@ export function createTransitionSteps({
         persistSession(worker);
       });
       worker.cwd = cwd;
-      await refreshWorkspaceContext(worker, cwd);
+      await refreshWorkspaceContext(worker, cwd, move);
       worker.updatedAt = Date.now();
       persistSession(worker);
     }
@@ -123,16 +135,10 @@ export function createTransitionSteps({
    * Apply the new workspace: runtime cwd, record, worker lock, prompt context
    * of the Lead and its idle workers, persistence. Journals the exact undo
    * (cwd, record, lock, prompts, worker roots) for a transaction that fails
-   * after this point.
+   * after this point. `move` ({ from, changes }: a move out of the project
+   * folder into a worktree) extends the prompt's working-folder notice.
    */
-  async function commit(session, previous, fields, journal) {
-    const moveLeadRow = (cwd) => {
-      try {
-        updateLeadWorkerCwd(session.id, cwd);
-      } catch {
-        /* the Lead pool must never break a transition */
-      }
-    };
+  async function commit(session, previous, fields, journal, move = null) {
     const next = normalizeSessionWorkspace({
       ...fields,
       revision: nextRevision(previous),
@@ -153,22 +159,70 @@ export function createTransitionSteps({
       prior.prompt();
       session.updatedAt = Date.now();
       persistSession(session);
-      moveLeadRow(prior.sessionCwd || prior.cwd);
+      moveLeadRow(session.id, prior.sessionCwd || prior.cwd);
       invalidateCaches();
     });
     applyResolvedCwd(next.cwd);
     session.cwd = next.cwd;
     session.workspace = next;
-    moveLeadRow(next.cwd);
+    moveLeadRow(session.id, next.cwd);
     setWorkspaceCwdLock(session.id, isWorktreeBound(next) ? next.cwd : null);
-    await refreshWorkspaceContext(session, next.cwd);
-    await retargetWorkers(session, next.cwd, journal);
+    await refreshWorkspaceContext(session, next.cwd, move);
+    await retargetWorkers(session, next.cwd, journal, move);
     session.updatedAt = Date.now();
-    persistSession(session);
+    // Awaited: a failed save fails the transaction (and its journal undoes it).
+    await persistSession(session);
     invalidateCaches();
     return { revision: next.revision, workspace: next };
   }
 
+  /**
+   * A Project switch (session set-project, the desktop/remote setCwd): the
+   * runtime cwd, session.cwd, workspace record and desktop classification
+   * move together (applyResolvedCwd with persistProjectSelection), then the
+   * prompt context of the Lead and its idle workers follows, awaited, before
+   * the switch completes. Journals the exact undo, so a failed refresh puts
+   * everything back and the failure reaches the caller.
+   */
+  async function switchProject(session, cwd, journal, { classifyByMembership = false } = {}) {
+    const sessionFields = ['cwd', 'workspace', 'desktopSession'].map((name) => [
+      name,
+      Object.hasOwn(session, name),
+      session[name],
+    ]);
+    const prior = {
+      cwd: getCurrentCwd(),
+      desktop: getDesktopSession(),
+      lock: workspaceCwdLock([session.id]),
+      prompt: snapshotPrompt(session),
+    };
+    journal.push(() => {
+      applyResolvedCwd(prior.cwd);
+      for (const [name, had, value] of sessionFields) {
+        if (had) session[name] = value;
+        else delete session[name];
+      }
+      setDesktopSession(prior.desktop);
+      setWorkspaceCwdLock(session.id, prior.lock);
+      prior.prompt();
+      session.updatedAt = Date.now();
+      persistSession(session);
+      moveLeadRow(session.id, session.cwd || prior.cwd);
+      invalidateCaches();
+    });
+    const changed = !samePath(prior.cwd || '', cwd);
+    applyResolvedCwd(cwd, { persistProjectSelection: true, classifyByMembership });
+    if (changed) {
+      moveLeadRow(session.id, cwd);
+      await refreshWorkspaceContext(session, cwd);
+      await retargetWorkers(session, cwd, journal);
+      session.updatedAt = Date.now();
+      persistSession(session);
+    }
+    invalidateCaches();
+    return { cwd: getCurrentCwd(), workspace: session.workspace ?? null };
+  }
+
   async function releaseOwner(backendApi, entryId, sessionId) {
     try {
       await backendApi.releaseWorktreeOwner(entryId, owner(sessionId));
@@ -178,7 +232,14 @@ export function createTransitionSteps({
     }
   }
 
-  async function enterWorktree(session, previous, { name, nameHint, confirmLarge, signal, txId, journal }) {
+  /**
+   * `changes` (a new worktree only): the project folder's uncommitted
+   * changes — `ask` refuses with WORKTREE_DIRTY_CHOICE while there are any,
+   * `leave` keeps them there, `carry` moves them into the worktree while the
+   * project folder is held (refused while other sessions work in it);
+   * omitted, they are not examined (lazy provisioning).
+   */
+  async function enterWorktree(session, previous, { name, nameHint, confirmLarge, changes, signal, txId, journal }) {
     const backendApi = await backend();
     const projectPath = previous.projectPath;
     const project = await inspectProject(projectPath, { signal });
@@ -197,16 +258,39 @@ export function createTransitionSteps({
       // The backend resolves the base branch commit (from the project
       // folder's checked-out branch), sizes and creates the checkout; the
       // txId makes a retried or duplicate send return the same worktree.
-      entry = await backendApi.createManagedWorktree({
-        projectPath,
-        sessionId: session.id,
-        runtimeToken,
-        baseBranch: project.currentBranch,
-        nameHint: name ?? nameHint ?? '',
-        confirmLarge: confirmLarge === true,
-        txId,
-        signal,
-      });
+      const create = () =>
+        backendApi.createManagedWorktree({
+          projectPath,
+          sessionId: session.id,
+          runtimeToken,
+          baseBranch: project.currentBranch,
+          nameHint: name ?? nameHint ?? '',
+          confirmLarge: confirmLarge === true,
+          txId,
+          signal,
+          carryChanges: changes ?? null,
+        });
+      // A carry clears the project folder: it is held, and every session
+      // sharing it must be quiet (no turn, agents or background shells).
+      entry =
+        changes === 'carry'
+          ? await withProjectFolder(session.id, project.topLevel || projectPath, async () => {
+              await assertCheckoutQuiet(session, project.topLevel || projectPath);
+              return create();
+            })
+          : await create();
+      const recoveryRef = entry.changes?.recoveryRef;
+      if (recoveryRef) {
+        // Anything that fails before the move is committed puts the changes
+        // back into the project folder and drops the worktree made for them;
+        // a restore that is refused keeps both (and the recovery ref).
+        const created = entry;
+        journal.push(async () => {
+          await backendApi.restoreCarriedChanges({ projectPath, recoveryRef });
+          await backendApi.removeManagedWorktree({ entryId: created.id, force: true });
+          await backendApi.dropCarryRecoveryRef({ projectPath, recoveryRef });
+        });
+      }
     }
     // Cancelled after the worktree exists: it stays retained (same txId on
     // retry), the session does not move.
@@ -228,10 +312,24 @@ export function createTransitionSteps({
         baseCommit: entry.baseCommit,
         mergeTarget: project.currentBranch,
       },
-      journal
+      journal,
+      // The tail notice: what happened to the uncommitted changes, and how
+      // the project-folder paths of the conversation so far map to the worktree.
+      isWorktreeBound(previous) ? null : { from: previous.cwd, changes: entry.changes?.mode ?? null }
     );
+    // The move is committed and persisted: the carried changes' recovery ref
+    // has done its job (a failure to drop it only leaves a spare ref).
+    if (entry.changes?.recoveryRef) {
+      await backendApi
+        .dropCarryRecoveryRef({ projectPath, recoveryRef: entry.changes.recoveryRef })
+        .catch(() => {});
+    }
     // Creation notes (submodules, include entries missing or already present).
-    return { ...entered, warnings: Array.isArray(entry.warnings) ? [...entry.warnings] : [] };
+    return {
+      ...entered,
+      warnings: Array.isArray(entry.warnings) ? [...entry.warnings] : [],
+      ...(entry.changes ? { changes: { mode: entry.changes.mode, count: entry.changes.count } } : {}),
+    };
   }
 
   async function enterProjectBranch(session, previous, { branch, create, signal, journal }) {
@@ -360,5 +458,5 @@ export function createTransitionSteps({
     return { ...result, removed };
   }
 
-  return { enterWorktree, enterProjectBranch, removeRetainedWorktree };
+  return { enterWorktree, enterProjectBranch, removeRetainedWorktree, switchProject };
 }