mixdog 1.3.2 → 1.3.4

package/src/session-runtime/internal-tool-executor/workspace-tools.mjs

@@ -9,6 +9,7 @@ import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator
 import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { turnHopOf } from '../../runtime/shared/bot-hops.mjs';
 import { scheduleCallerScope } from '../services/schedule-access.mjs';
+import { worktreeCallerScope } from '../services/worktree-access.mjs';
 import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
@@ -44,9 +45,6 @@ export function createWorkspaceToolHandlers({
   getLifecycleApi = () => null,
   executeSessionControl = null,
 }) {
-  // The Lead's own worktree, on the user's request: the same authority the
-  // branch chip menu drives, tolerating the calling turn but nothing else
-  // running (workers, background shells).
   const assertLead = (action, callerCtx) => {
     const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
     if (!rt.session?.id || callerSessionId !== rt.session.id) {
@@ -55,24 +53,6 @@ export function createWorkspaceToolHandlers({
     return rt.session.id;
   };
 
-  const worktreeAction = async (action, args, callerCtx) => {
-    const workspace = getWorkspaceApi();
-    if (!workspace) throw new Error(`session: ${action} is unavailable in this runtime`);
-    assertLead(action, callerCtx);
-    let result;
-    if (action === 'merge-worktree') {
-      result = await workspace.mergeWorkspace({ confirmed: true }, { ownTurn: true });
-    } else if (action === 'remove-worktree') {
-      result = await workspace.removeWorktree({ force: args?.force === true }, { ownTurn: true });
-    } else if (action === 'list-worktrees') {
-      result = await workspace.listWorktrees();
-    } else {
-      result = await workspace.pruneWorktrees();
-    }
-    return JSON.stringify({ action, cwd: rt.currentCwd, result }, null, 2);
-  };
-
-  const WORKTREE_ACTIONS = new Set(['merge-worktree', 'remove-worktree', 'list-worktrees', 'prune-worktrees']);
   const SIDEBAR_ACTIONS = new Set(['favorite', 'archive']);
 
   // Sidebar flags only (the desktop's favorite/archive metadata).
@@ -127,6 +107,8 @@ export function createWorkspaceToolHandlers({
             callerAgentId,
             callerCwd,
             ...(action === 'send' || action === 'create' ? { callerHop: turnHopOf(rt.session) } : {}),
+            // Whether a create may provision a worktree (worktree-access.mjs).
+            ...(action === 'create' ? { callerScope: worktreeCallerScope(rt.session) } : {}),
             // Which bots and sessions it may see (bot-status.mjs).
             ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
             ...(attachmentParts.length ? { attachmentParts } : {}),
@@ -137,7 +119,6 @@ export function createWorkspaceToolHandlers({
     if (target && target !== assertLead(action, callerCtx)) {
       throw new Error(`session: action=${action} only applies to the current session`);
     }
-    if (WORKTREE_ACTIONS.has(action)) return worktreeAction(action, args, callerCtx);
     if (SIDEBAR_ACTIONS.has(action)) return sidebarAction(action, args, callerCtx);
     let currentCwd = callerCwd;
     if (action === 'status' || action === 'list-projects' || action === 'set-project') assertLead(action, callerCtx);
@@ -265,6 +246,8 @@ export function createWorkspaceToolHandlers({
         clientHostPid: callerCtx?.clientHostPid || rt.session?.clientHostPid || process.pid,
         signal: callerCtx?.signal,
         notifyFn: notifyFnForSession(callerSessionId),
+        // The jobs it starts report back at this turn's bot-chain hop (bot-hops.mjs).
+        ...(turnHopOf(rt.session) > 0 ? { hop: turnHopOf(rt.session) } : {}),
         // The jobs this call starts are recorded under it (agent-task-starts.mjs).
         ...(callerCtx?.toolCallId ? { toolCallId: callerCtx.toolCallId } : {}),
       });

package/src/session-runtime/model-recency.mjs

@@ -11,6 +11,7 @@ function customRowFields(name, m) {
   if (!isCustomProviderName(name)) return {};
   return {
     ...(typeof m.name === 'string' && m.name ? { name: m.name } : {}),
+    ...(typeof m.providerName === 'string' && m.providerName ? { providerName: m.providerName } : {}),
     ...(typeof m.hidden === 'boolean' ? { hidden: m.hidden } : {}),
     ...(typeof m.manual === 'boolean' ? { manual: m.manual } : {}),
     ...(m.customReasoning && typeof m.customReasoning === 'object' ? { customReasoning: m.customReasoning } : {}),

package/src/session-runtime/provider-models/row-hydration.mjs

@@ -45,8 +45,15 @@ export function hydrateProviderModelRow(cfg, row) {
   const modelParameterOptions = addedOptions.length
     ? [...existingOptions.filter((option) => !addedOptions.some((added) => added.id === option?.id)), ...addedOptions]
     : row.modelParameterOptions;
+  const isCustom = row.provider?.startsWith?.('custom-');
+  const customName = isCustom ? String(cfg?.providers?.[row.provider]?.name || '').trim() : '';
+  // A custom provider's name always comes from the current configuration; a
+  // row's own (possibly renamed or removed) name is dropped.
+  const base = { ...row };
+  if (isCustom) delete base.providerName;
   return {
-    ...row,
+    ...base,
+    ...(customName ? { providerName: customName } : {}),
     ...(alias ? { display: alias, displayAlias: alias } : {}),
     ...(modelParameterOptions ? { modelParameterOptions } : {}),
     effortOptions: effortItemsFor(row.provider, row, null),

package/src/session-runtime/quick-model-rows/model-meta.mjs

@@ -5,10 +5,12 @@ import { getModelMetadataSync } from '../../runtime/agent/orchestrator/providers
 import { isCustomProviderName } from '../../runtime/agent/orchestrator/providers/custom-reasoning.mjs';
 
 const CUSTOM_DECLARED_FIELDS = [
+  'supportsVision',
   'supportsReasoning',
   'reasoningOptions',
   'reasoningLevels',
   'reasoningContentField',
+  'providerName',
   'hidden',
   'manual',
   'customReasoning',

package/src/session-runtime/quick-model-rows/provider-rows.mjs

@@ -22,7 +22,10 @@ function customProviderModels(provider, providerConfig, discovered = providerCac
   } catch {
     return [];
   }
-  return effectiveCustomModelRows(config, discovered, { providerId: provider });
+  const providerName = clean(config.name);
+  return effectiveCustomModelRows(config, discovered, { providerId: provider }).map((row) =>
+    providerName ? { ...row, providerName } : row
+  );
 }
 
 export function createQuickProviderRows({
@@ -53,6 +56,8 @@ export function createQuickProviderRows({
         display: model.display || model.name || modelId,
         contextWindow: model.contextWindow || meta.contextWindow || null,
         outputTokens: model.outputTokens || meta.outputTokens || null,
+        // An explicit value (an override's false included) wins; the catalog fills the rest.
+        supportsVision: model.supportsVision ?? meta.supportsVision,
         supportsReasoning: model.supportsReasoning === true || meta.supportsReasoning === true,
         supportsFunctionCalling: model.supportsFunctionCalling === true || meta.supportsFunctionCalling === true,
         supportsPromptCaching: model.supportsPromptCaching === true || meta.supportsPromptCaching === true,
@@ -78,6 +83,7 @@ export function createQuickProviderRows({
         contextWindow: meta.contextWindow || null,
         outputTokens: meta.outputTokens || null,
         latest: routeLike.latest === true,
+        supportsVision: meta.supportsVision,
         supportsReasoning: !!routeLike.effort || meta.supportsReasoning === true,
         supportsFunctionCalling: meta.supportsFunctionCalling === true,
         supportsPromptCaching: meta.supportsPromptCaching === true,

package/src/session-runtime/runtime-review-api.mjs

@@ -2,6 +2,7 @@ import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
   clearSessionChangeHistory,
+  forgetTurnSnapshotSession,
   getSessionReviewDiff,
   getSessionReviewFilePatch,
   getTurnChanges,
@@ -19,8 +20,10 @@ import { registerSessionPurgeHook } from '../runtime/agent/orchestrator/session/
 
 // A deleted history stays deleted for as long as its session exists; the
 // session's own deletion takes the marker — and its stored first-seen file
-// contents — with it.
+// contents — with it, and its in-memory turn, parked worker reviews and
+// bound worker trackers.
 registerSessionPurgeHook((sessionId) => {
+  forgetTurnSnapshotSession(sessionId);
   void forgetSessionChangeHistoryMarker(sessionId);
   void forgetSessionBaselines(sessionId);
 });

package/src/session-runtime/services/agent-tool/close-flow.mjs

@@ -5,7 +5,7 @@ import {
   listBackgroundTasks,
   taskIdFromArgs,
 } from '../../../runtime/shared/background-tasks.mjs';
-import { agentScope, clean, clearAgentStatuslineRoute } from './helpers.mjs';
+import { agentScope, clean, clearAgentStatuslineRoute, sessionMatchesContext } from './helpers.mjs';
 import { isLeadPoolAgent } from './worker-rows.mjs';
 import { createCloseAll } from './close-flow/close-all.mjs';
 import { closeManagedSession } from '../../lifecycle/shared.mjs';
@@ -20,6 +20,16 @@ export function createCloseFlow({ mgr, registry, views }) {
   // Stale local metadata only: resolveTag found no session in this
   // terminal/scope, so there is no sessionId-safe worker row to delete. Never
   // turn it into a tag-wide persisted-row removal.
+  // `tags`/`tagAgents` are shared by every caller on the canonical agent, so a
+  // binding alone does not prove the caller owns it: only a live session or a
+  // persisted row inside the caller's scope does. Another session's tag must
+  // stay untouched.
+  function tagBoundByCaller(target, scopedContext) {
+    const live = registry.getLiveSession(tags.get(target));
+    if (live) return sessionMatchesContext(live, scopedContext);
+    return registry.readWorkerRows(scopedContext).some((row) => clean(row.tag) === target);
+  }
+
   function forgetStaleLocalTag(target, task) {
     registry.unbindTag(target);
     if (task?.taskId) cancelBackgroundTask(task.taskId, CLOSE_REASON);
@@ -55,7 +65,9 @@ export function createCloseFlow({ mgr, registry, views }) {
     }
     const sessionId = registry.resolveTag(target, scopedContext, { scanSessions: registry.wantsSessionScan(args) });
     if (!sessionId) {
-      if (!target.startsWith('sess_') && tagAgents.has(target)) return forgetStaleLocalTag(target, task);
+      if (!target.startsWith('sess_') && tagAgents.has(target) && tagBoundByCaller(target, scopedContext)) {
+        return forgetStaleLocalTag(target, task);
+      }
       throw new Error(`agent close: target "${target}" not found`);
     }
     if (isLeadPoolAgent(registry.getLiveSession(sessionId)?.agent)) {

package/src/session-runtime/services/agent-tool/execute.mjs

@@ -67,7 +67,12 @@ export function createAgentExecute({
           }
           // Targetless status is the same compact overview as list.
           return renderResult({
-            workers: views.list({ scanSessions: registry.wantsSessionScan(args), context: scopedContext }),
+            // Idle workers stay open for follow-ups; the model must see them to close them.
+            workers: views.list({
+              scanSessions: registry.wantsSessionScan(args),
+              context: scopedContext,
+              includeIdle: true,
+            }),
             jobs: views.listJobs(scopedContext),
           });
         case 'read':

package/src/session-runtime/services/agent-tool/job-views/agent-list.mjs

@@ -25,11 +25,24 @@ export function isActiveWorkerRow(row = {}) {
   return !isTerminalWorkerStatus(effective);
 }
 
-function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
+// A finished worker that is still open: it takes follow-ups and can be closed.
+function isOpenIdleRow(row = {}) {
+  const status = String(row.status ?? '').trim().toLowerCase();
+  const stage = String(row.stage ?? '').trim().toLowerCase();
+  if (CANCELLED_WORKER_STATUS.test(stage) || CANCELLED_WORKER_STATUS.test(status)) return false;
+  return (status || stage) === 'idle';
+}
+
+function rowState(session, runtime) {
   const status = session.closed === true ? 'closed' : session.status || 'idle';
   const stage =
     session.stage ||
     (status === 'idle' || status === 'error' || status === 'closed' ? status : runtime?.stage || status);
+  return { status, stage };
+}
+
+function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
+  const { status, stage } = rowState(session, runtime);
   // Additive: the current turn's start (worker index, stamped at dispatch) so
   // surfaces time a continued worker from its turn, not from createdAt.
   const turnStartedAt = indexRow?.turnStartedAt || session.turnStartedAt || null;
@@ -73,27 +86,38 @@ function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
 }
 
 export function createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntries, progress }) {
-  return function list({ scanSessions = false, context = {}, includeTerminal = false } = {}) {
+  return function list({ scanSessions = false, context = {}, includeTerminal = false, includeIdle = false } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
-    const rows = agentSessionEntries({ scanSessions, context }).map(({ tag, session, indexRow, loaded }) =>
-      agentRow({
-        tag,
-        session,
-        indexRow,
-        runtime: mgr.getSessionRuntime?.(session.id),
-        // A tag-bound entry is the getSession answer itself; an index row or
-        // a scanned summary is only a projection and still reads the session.
-        progress: progress.sessionProgressExtras(
-          session.id,
-          session.agent || null,
+    const rows = [];
+    for (const { tag, session, indexRow, loaded } of agentSessionEntries({ scanSessions, context })) {
+      const runtime = mgr.getSessionRuntime?.(session.id);
+      // Whether a row is listed depends on its status and stage alone, so a
+      // finished worker is dropped before its progress is read: that read
+      // loads the worker's stored session, and a Lead's status pulse (every
+      // 2 s) would otherwise read every worker it ever ran, whole transcripts
+      // on first sight, synchronously on the daemon loop.
+      const state = rowState(session, runtime);
+      if (!includeTerminal && !isActiveWorkerRow(state) && !(includeIdle && isOpenIdleRow(state))) continue;
+      rows.push(
+        agentRow({
+          tag,
+          session,
+          indexRow,
+          runtime,
+          // A tag-bound entry is the getSession answer itself; an index row or
+          // a scanned summary is only a projection and still reads the session.
+          progress: progress.sessionProgressExtras(
+            session.id,
+            session.agent || null,
+            now,
+            null,
+            loaded ? { loaded: session } : {}
+          ),
           now,
-          null,
-          loaded ? { loaded: session } : {}
-        ),
-        now,
-      })
-    );
-    return includeTerminal ? rows : rows.filter((row) => isActiveWorkerRow(row));
+        })
+      );
+    }
+    return rows;
   };
 }

package/src/session-runtime/services/agent-tool/render.mjs

@@ -156,9 +156,11 @@ export function renderResult(value, { includeDiagnostics = false } = {}) {
   if (typeof value === 'string') return value;
   if (value && typeof value === 'object') {
     if (Array.isArray(value.workers) || Array.isArray(value.jobs)) return renderRoster(value);
+    // close-flow results carry `closed` plus task_id: render the close outcome.
+    // close-flow results carry `closed` plus task_id: render the close outcome.
+    if (value.closed !== undefined) return renderClosed(value);
     if (value.task_id) return renderTask(value, includeDiagnostics);
     if (value.queued) return renderQueued(value);
-    if (value.closed !== undefined) return renderClosed(value);
     if (value.content !== undefined) return renderContent(value);
   }
   return JSON.stringify(value, null, 2);

package/src/session-runtime/services/agent-tool/spawn-flow/job-start.mjs

@@ -9,6 +9,7 @@ import { resourceAdmission } from '../../../../runtime/shared/resource-admission
 import { clean, terminalPidForContext } from '../helpers.mjs';
 import { renderResult } from '../render.mjs';
 import { closeManagedSession } from '../../../lifecycle/shared.mjs';
+import { hopOf } from '../../../../runtime/shared/bot-hops.mjs';
 
 /** The completion callback that hands a worker's result back to its caller session; null without a handoff. */
 function handoffNotifier(handoffSessionId, notifySessionCompletion) {
@@ -30,6 +31,8 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
       ownerSessionId: ownerSessionId || null,
       clientHostPid: clientHostPid || null,
       notifyFn: handoffNotifier(handoffSessionId, notifySessionCompletion),
+      // The turn that started the job: its completion returns at that bot-chain hop (bot-hops.mjs).
+      ...(hopOf(notifyContext?.hop) ? { hop: notifyContext.hop } : {}),
     };
     const jobMeta = sanitizeTaskMeta({
       ...(meta || {}),

package/src/session-runtime/services/agent-tool/tool-def.mjs

@@ -28,7 +28,7 @@ export const AGENT_TOOL = {
     agentHidden: false,
   },
   description:
-    'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Wait for completion notifications; use status/read only for manual recovery.',
+    'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Wait for completion notifications; use status/read only for manual recovery. Close finished agents yourself.',
   inputSchema: {
     type: 'object',
     properties: {

package/src/session-runtime/services/provider-admin.mjs

@@ -442,6 +442,7 @@ function publicCustomModelRows(rows) {
     model.hidden = item.hidden === true;
     model.manual = item.manual === true;
     for (const key of [
+      'supportsVision',
       'supportsReasoning',
       'reasoningOptions',
       'reasoningLevels',
@@ -588,7 +589,8 @@ async function modelProxyProviderSetup(options) {
       });
   const custom = Object.entries(providers)
     .filter(([id, entry]) => isCustomProviderId(id) && entry?.type === 'custom')
-    .map(([id]) => ({ id, name: id }));
+    // Older desktops advertise no name: the id is the fallback.
+    .map(([id, entry]) => ({ id, name: (typeof entry.name === 'string' && entry.name.trim()) || id }));
   return {
     managedByClient: true,
     api: [...project(API_PROVIDERS, 'api', 'api-key'), ...project(custom, 'api', 'custom')],
@@ -1111,7 +1113,15 @@ export async function saveCustomProvider(cfgMod, rawInput) {
   return typed ? serializeCustomKeySave(id, commit) : commit();
 }
 
-const MODEL_PATCH_KEYS = new Set(['manual', 'hidden', 'name', 'contextWindow', 'maxOutputTokens', 'reasoning']);
+const MODEL_PATCH_KEYS = new Set([
+  'manual',
+  'hidden',
+  'name',
+  'contextWindow',
+  'maxOutputTokens',
+  'supportsVision',
+  'reasoning',
+]);
 const REASONING_PATCH_KEYS = new Set(['levels', 'wireFormat', 'wireValues', 'replay']);
 
 // Tri-state merge: undefined preserves, null deletes the property, a value replaces it.

package/src/session-runtime/services/worktree-access.mjs

@@ -0,0 +1,27 @@
+// Who may change worktrees from a chat (the git tool's managed-worktree
+// operations, the daemon's cross-session `worktree` control). A worktree
+// mutation — entering, returning, merging, removing, pruning, `git worktree
+// add/remove`, a snapshot — runs only in a conversation session: a Lead
+// session of the desktop or TUI, or a bot's chat. Unattended runs (schedules,
+// webhooks, routines, room seats) are refused by the run's trusted identity;
+// delegated workers have no worktree host at all. Listing stays open.
+//
+// The scope is the session-level caller scope (schedule-access.mjs
+// scheduleCallerScope: the session's provenance and its unattended-run mark),
+// never anything the model or a message supplies.
+import { scheduleCallerScope } from './schedule-access.mjs';
+
+/** `{ kind, agentId?, unattended?, attended }` of a calling session record. */
+export function worktreeCallerScope(session) {
+  const scope = scheduleCallerScope(session);
+  const attended = (scope.kind === 'human' || scope.kind === 'agent') && scope.unattended !== true;
+  return { ...scope, attended };
+}
+
+/** Throws unless `scope` (worktreeCallerScope) may change worktrees; `what` names the refused action. */
+export function assertWorktreeMutationAllowed(scope, what) {
+  if (scope?.attended === true) return;
+  throw new Error(
+    `${what} changes worktrees only in a conversation session (a Lead session or a bot chat); schedule, webhook, routine and room runs may only list them`
+  );
+}

package/src/session-runtime/session-hooks.mjs

@@ -5,9 +5,6 @@
 // facade's hookCommonPayload / currentCwd accessor + the session itself. All
 // properties are non-enumerable/configurable/writable so the loop/manager can
 // read them by name without changing session enumeration.
-import { roomMemberOfSession } from '../runtime/agent/orchestrator/session/agent-room.mjs';
-import { roomMemberToolDecision } from './room-member-gate.mjs';
-
 export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }) {
   const identity = (input) => ({
     session_id: input?.sessionId || input?.session_id || session?.id,
@@ -28,26 +25,21 @@ export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }
   // rejection cannot escape the tool loop or the compaction flow.
   const dispatcher = (event, payload) => (input) => hooks.dispatch(event, hookCommonPayload(payload(input)));
 
-  // PreToolUse bridge. A group-room member's mutating calls always ask the
-  // user (room-member-gate.mjs), whatever the hooks decided short of a deny.
-  define('beforeToolHook', async (input, options = {}) => {
-    const name = input?.name || input?.tool_name;
-    const args = input?.args || input?.tool_input;
-    const cwd = input?.cwd || getCwd();
-    const decision = await hooks.beforeTool(
+  // PreToolUse bridge. A group-room member follows the same rules as its
+  // agent's home thread: no room-only approval on top.
+  define('beforeToolHook', async (input, options = {}) =>
+    hooks.beforeTool(
       hookCommonPayload({
         ...input,
         session_id: input?.sessionId || input?.session_id || session?.id,
-        tool_name: name,
-        tool_input: args,
+        tool_name: input?.name || input?.tool_name,
+        tool_input: input?.args || input?.tool_input,
         tool_use_id: input?.toolCallId || input?.tool_use_id,
-        cwd,
+        cwd: input?.cwd || getCwd(),
       }),
       options
-    );
-    if (!roomMemberOfSession(session?.id)) return decision;
-    return roomMemberToolDecision({ name, args, cwd }, decision);
-  });
+    )
+  );
   // PostToolUse: bridge runtime tool completions to the standard hook bus.
   define('afterToolHook', dispatcher('PostToolUse', toolPayload));
   // PostToolUseFailure: dispatched by loop.mjs only when a tool execution

package/src/session-runtime/settings-builtin-tools-api.mjs

@@ -19,6 +19,7 @@ import {
   effortJudgeAvailable,
   effortJudgeInfo,
   effortJudgeInstalling,
+  effortJudgeLastError,
   effortJudgeReady,
   shutdownEffortJudge,
 } from '../runtime/effort-judge/judge-client.mjs';
@@ -178,6 +179,7 @@ export function createBuiltinToolSettings(
           installed: effortJudgeAvailable(),
           installing: effortJudgeInstalling(),
           ready: effortJudgeReady(),
+          lastError: effortJudgeLastError(),
           info: effortJudgeInfo(),
         },
       };

package/src/session-runtime/setup-tool/executor.mjs

@@ -38,6 +38,10 @@ const PROFILE_VALUE_IDS = Object.freeze({
 });
 
 const ACTION_APPLIES_TO = {
+  set_agent_route:
+    "the bot's chats from their next turn (a running turn finishes on the old model); an agent switched on or off reaches open conversations from their next turn as an agent list reminder",
+  set_orchestration_mode:
+    "new sessions and an empty current one (the default mode); a conversation keeps its own mode until it is switched with the composer's mode selector",
   set_recap_enabled: 'background Memory cycles; no restart required',
   set_auto_update: 'subsequent automatic update checks',
   set_worktree_settings: 'new tasks and worktrees created afterwards; existing worktrees are unchanged',

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -223,6 +223,9 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     turnNotifications: boolean,
     usagePinned: boolean,
     usageRailShortLong: boolean,
+    usageAccountsExpanded: boolean,
+    usageRailSlotsThree: boolean,
+    usageRailSlotsAll: boolean,
     computerObserveOnly: boolean,
     browserAutoSignIn: boolean,
     notificationVolume: {