mixdog 1.3.5 → 1.4.1

package/src/session-runtime/setup-tool/session-route-actions.mjs

@@ -0,0 +1,152 @@
+/** Setup actions that act on one running session rather than a setting: its
+ *  fallback position (read in status model/agents), a return to its primary
+ *  route, and its quota card's actions. The caller's own session changes
+ *  through its runtime; another session through the daemon's configure lane
+ *  (daemon-session-control/route-control.mjs), the lane the model picker and
+ *  quota card use. */
+import {
+  liveRouteFallbackPositions,
+  routeFallbackHopped,
+  routeFallbackPosition,
+  routeLeaf,
+  sessionChainSource,
+  sessionRoutePrimary,
+} from '../../runtime/agent/orchestrator/session/manager/route-fallback-chain.mjs';
+import { sameRouteModel } from '../../runtime/agent/orchestrator/session/manager/owner-route-fallbacks.mjs';
+import { resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { _liveSessions } from '../../runtime/agent/orchestrator/session/store/live-state.mjs';
+import { assertOwnAgentSettings } from '../services/schedule-access.mjs';
+import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+
+const modelOf = (route) => ({ provider: route?.provider || '', model: route?.model || '' });
+
+/** The calling session's fallback position, and those of the other sessions
+ *  held here that `keep` selects (status model: Leads; status agents: bots and agents). */
+export function routePositionsStatus({ caller, config, keep }) {
+  return {
+    ...(caller?.agent ? { session: routeFallbackPosition(caller, config) } : {}),
+    sessions: liveRouteFallbackPositions(config, (row) => row.sessionId !== caller?.id && keep(row)),
+  };
+}
+
+/** The route a reset returns `session` to: the one it left at its first hop,
+ *  else its settings' route when that is still its primary. */
+function primaryRoute(session, config) {
+  if (session.routeFallbackPrimary?.provider) return routeLeaf(session.routeFallbackPrimary);
+  const primary = sessionRoutePrimary(session);
+  const source = sessionChainSource(session, config);
+  return source && sameRouteModel(source, primary) ? routeLeaf(source) : routeLeaf(primary);
+}
+
+const actingAgentOf = (session) => resolveSessionMode({ session }).agentId || clean(session?.agent);
+
+function createSessionTargets(ctx) {
+  const { sessionId: callerId, caller, getSession, scope, executeSessionControl } = ctx;
+  const load = (id) => (id === callerId ? caller : getSession?.(id)) || null;
+  // A bot's thread acts only on its own sessions; the human's on any.
+  const assertTarget = (session, action) => {
+    if (scope) assertOwnAgentSettings(scope, actingAgentOf(session), action);
+  };
+  const target = (id, action, { other = false } = {}) => {
+    const sessionId = clean(id) || callerId;
+    if (!sessionId) throw new Error('sessionId is required');
+    if (other && sessionId === callerId) {
+      throw new Error(`${action} applies to another session: this one is running the setup call`);
+    }
+    const session = load(sessionId);
+    if (!session || session.closed === true) throw new Error(`session ${sessionId} not found`);
+    assertTarget(session, action);
+    return session;
+  };
+  const control = async (session, method, input) => {
+    if (typeof executeSessionControl !== 'function') {
+      throw new Error('Another session is reachable only through the Mixdog app or daemon; none hosts this runtime');
+    }
+    return executeSessionControl(
+      { action: 'route', session_id: session.id, method, ...(input ? { input } : {}) },
+      { callerSessionId: callerId }
+    );
+  };
+  return { load, target, control, assertTarget };
+}
+
+export const SESSION_ROUTE_HANDLERS = {
+  async reset_route_fallback(rt, args, ctx) {
+    if (Object.hasOwn(args, 'sessionId') && Object.hasOwn(args, 'agent')) {
+      throw new Error('Pass sessionId or agent, not both');
+    }
+    const config = ctx.getConfig();
+    const sessions = createSessionTargets(ctx);
+    let targets;
+    if (Object.hasOwn(args, 'agent')) {
+      const agent = clean(args.agent);
+      if (!agent) throw new Error('agent is required');
+      if (ctx.scope) assertOwnAgentSettings(ctx.scope, agent, 'reset_route_fallback');
+      // Its chats held here (home, room seats) and its home thread from disk.
+      const byId = new Map();
+      for (const session of _liveSessions.values()) {
+        if (session?.id && session.closed !== true && resolveSessionMode({ session }).agentId === agent) {
+          byId.set(session.id, session);
+        }
+      }
+      const home = agentHomeSessionId(agent);
+      if (home && !byId.has(home)) {
+        const stored = sessions.load(home);
+        if (stored && stored.closed !== true) byId.set(home, stored);
+      }
+      targets = [...byId.values()];
+    } else {
+      targets = [sessions.target(args.sessionId, 'reset_route_fallback')];
+    }
+    const reset = [];
+    const unchanged = [];
+    for (const session of targets) {
+      if (!routeFallbackHopped(session)) {
+        unchanged.push({ sessionId: session.id, current: modelOf(session) });
+        continue;
+      }
+      const route = primaryRoute(session, config);
+      // The session's own model pick, from its next turn: the switch restarts
+      // its chain (fallback index and failures cleared).
+      if (session.id === ctx.sessionId) {
+        await rt.setRoute(route, { sessionOnly: true, switchEstablished: true, deferUntilNextTurn: true });
+      } else {
+        await sessions.control(session, 'setRoute', route);
+      }
+      reset.push({ sessionId: session.id, from: modelOf(session), to: modelOf(route) });
+    }
+    return { scope: 'session', reset, ...(unchanged.length ? { alreadyOnPrimary: unchanged } : {}) };
+  },
+  async continue_in_model(_rt, args, ctx) {
+    const sessions = createSessionTargets(ctx);
+    const session = sessions.target(args.sessionId, 'continue_in_model', { other: true });
+    const route = routeLeaf(args.route);
+    const continued = (await sessions.control(session, 'continueSessionInModel', route)) !== false;
+    return {
+      scope: 'session',
+      sessionId: session.id,
+      continued,
+      route: modelOf(route),
+      note: 'The stopped turn is not resent: the user resumes it from that conversation (Resume, or a new message).',
+    };
+  },
+  async schedule_quota_resume(_rt, args, ctx) {
+    const sessions = createSessionTargets(ctx);
+    const session = sessions.target(args.sessionId, 'schedule_quota_resume', { other: true });
+    return {
+      scope: 'session',
+      sessionId: session.id,
+      scheduled: (await sessions.control(session, 'scheduleQuotaResume')) === true,
+    };
+  },
+  async cancel_quota_resume(_rt, args, ctx) {
+    const sessions = createSessionTargets(ctx);
+    const session = sessions.target(args.sessionId, 'cancel_quota_resume', { other: true });
+    return {
+      scope: 'session',
+      sessionId: session.id,
+      cancelled: (await sessions.control(session, 'cancelQuotaResume')) === true,
+    };
+  },
+};

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

@@ -42,7 +42,7 @@ export const SETUP_EXTENDED_ACTION_FIELDS = Object.freeze({
 });
 
 /** Mirrors RULE_ACTIONS in services/hook-bus/rule-store.mjs. */
-export const SETUP_HOOK_RULE_ACTIONS = Object.freeze(['allow', 'deny', 'block', 'modify', 'rewrite', 'ask']);
+const SETUP_HOOK_RULE_ACTIONS = Object.freeze(['allow', 'deny', 'block', 'modify', 'rewrite', 'ask']);
 
 /** Mirrors ACTIVITY_RAIL_PIN_IDS in apps/desktop/src/shared/activity-rail-pins.ts. */
 export const SETUP_ACTIVITY_RAIL_PIN_IDS = Object.freeze([
@@ -224,7 +224,6 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
   desktop: object({
     keepAwake: boolean,
     runInBackground: boolean,
-    turnNotifications: boolean,
     usagePinned: boolean,
     usageRailShortLong: boolean,
     usageAccountsExpanded: boolean,
@@ -232,6 +231,7 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     usageRailSlotsAll: boolean,
     computerObserveOnly: boolean,
     browserAutoSignIn: boolean,
+    saveChatLogins: boolean,
     notificationVolume: {
       type: 'integer',
       minimum: 0,
@@ -273,7 +273,8 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     sidePanelPosition: {
       type: 'string',
       enum: ['right', 'bottom', 'auto'],
-      description: 'Where the side dock sits on desktop: beside the chat, below it, or by window shape (default right).',
+      description:
+        'Where the side dock sits on desktop: beside the chat, below it, or by window shape (default right).',
     },
     timeFormat: {
       type: 'string',

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

@@ -6,10 +6,17 @@ import {
 } from './settings-contract.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { INSTRUCTION_FILES_MODES } from '../../runtime/shared/instruction-files-mode.mjs';
+import {
+  DEFAULT_HEARTBEAT_INTERVAL_MINUTES,
+  HEARTBEAT_INTERVAL_CHOICES,
+} from '../../runtime/shared/heartbeat-interval.mjs';
 import { AUTO_EFFORT_BASES } from '../../runtime/agent/orchestrator/providers/auto-effort.mjs';
 import { WORKTREE_NEW_TASK_DEFAULTS } from '../../runtime/shared/worktrees/settings.mjs';
 import { CONNECTOR_IDS } from '../../runtime/shared/connector-catalog.mjs';
 import { COMPACTION_SUMMARY_MODES } from '../../runtime/agent/orchestrator/session/compact/summary-mode.mjs';
+import { ACTION_KINDS } from '../../runtime/agent/orchestrator/session/human-gate/outbound-policy.mjs';
+import { PERMISSION_MODES } from '../../runtime/agent/orchestrator/session/human-gate/store.mjs';
+import { CONNECTOR_PERMISSIONS } from '../../runtime/agent/orchestrator/mcp/agent-connectors.mjs';
 
 /** Built-in `setup` tool: the model's handle on a Mixdog user's persisted
  *  configuration. The description is a contract only; how to use each action
@@ -104,6 +111,7 @@ export const SETUP_ACTION_FIELDS = Object.freeze({
   set_quota_auto_resume: 'enabled',
   set_model_preferences: 'provider model hidden? favorite?',
   set_heartbeat_enabled: 'enabled',
+  set_heartbeat_interval: 'minutes',
   set_reactions_enabled: 'enabled',
   forget_provider_auth: 'name accountId?',
   set_provider_account: 'name providerAccount',
@@ -121,6 +129,19 @@ export const SETUP_ACTION_FIELDS = Object.freeze({
   enable_plugin_mcp: 'name',
   connect_connector: 'connector',
   set_worktree_settings: 'worktree',
+  reset_route_fallback: 'sessionId? agent?',
+  continue_in_model: 'sessionId route',
+  schedule_quota_resume: 'sessionId',
+  cancel_quota_resume: 'sessionId',
+  set_cache_warming_enabled: 'enabled',
+  read_agent_settings: 'agent',
+  read_project_connectors: 'projectPath',
+  set_agent_permission: 'agent actionKind permissionMode',
+  set_agent_connector: 'agent name enabled',
+  set_agent_connector_tool: 'agent name tool permission',
+  set_project_connector: 'projectPath name enabled',
+  restore_definition: 'definitionKind name',
+  set_bot_order: 'botOrder',
   ...SETUP_EXTENDED_ACTION_FIELDS,
 });
 
@@ -170,7 +191,7 @@ const ROUTE_SCHEMA = {
 ROUTE_SCHEMA.properties.fallbacks = {
   type: 'array',
   description:
-    'Lead (set_route), agent (bots included) and Web Search routes only: ordered fallback models tried when the model hits its usage limit or is unavailable; [] clears the list.',
+    'Lead (set_route), agent (bots included) and Web Search routes only: ordered fallback models tried when the model hits its usage limit or is unavailable, each on another provider; [] clears the list. Running sessions on that route read it at their next hop.',
   items: {
     type: 'object',
     additionalProperties: false,
@@ -219,7 +240,11 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           description:
             'Partial route update; omitted fields are preserved. Agent or Web Search provider "" restores Main inheritance. contextPercent and contextTokens apply to Main and agent routes only.',
         },
-        agent: { type: 'string', description: 'set_agent_route: agent id.' },
+        agent: {
+          type: 'string',
+          description:
+            'Agent or bot id (lead = Mixy): set_agent_route, read_agent_settings, set_agent_permission, set_agent_connector(_tool); reset_route_fallback: every chat of that bot.',
+        },
         workflow: { type: 'string', description: 'set_workflow: pack id.' },
         style: { type: 'string', description: 'set_output_style: style id.' },
         profile: {
@@ -272,7 +297,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         enabled: {
           type: 'boolean',
           description:
-            'Boolean setters (set_*_enabled, set_compaction, set_auto_update, set_ai_session_titles, set_quota_auto_resume, set_heartbeat_enabled, set_mcp_enabled, set_plugin_enabled).',
+            'Boolean setters (set_*_enabled, set_compaction, set_auto_update, set_ai_session_titles, set_quota_auto_resume, set_heartbeat_enabled, set_mcp_enabled, set_plugin_enabled, set_agent_connector, set_project_connector).',
         },
         provider: { type: 'string', description: 'set_model_preferences: provider id.' },
         hidden: {
@@ -297,12 +322,12 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         },
         name: {
           type: 'string',
-          description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. revoke_linked_device: client id from status connection, not its display name; set_developer_option: option id from status developer; read_definition/delete_definition: the definition id; reconnect_mcp: optional MCP server name (omit for all); else MCP/plugin/provider id.`,
+          description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. revoke_linked_device: client id from status connection, not its display name; set_developer_option: option id from status developer; read_definition/delete_definition: the definition id; reconnect_mcp: optional MCP server name (omit for all); set_agent_connector(_tool)/set_project_connector: connector (MCP server) id from read_agent_settings; restore_definition: archived agent id; else MCP/plugin/provider id.`,
         },
         accountId: {
           type: 'string',
           description:
-            'forget_provider_auth: OAuth account id from status providers with detail:true; required when the provider has several accounts. set_media_default: optional account of the OAuth lane to pin; omitted = the lane provider\'s selected account.',
+            "forget_provider_auth: OAuth account id from status providers with detail:true; required when the provider has several accounts. set_media_default: optional account of the OAuth lane to pin; omitted = the lane provider's selected account.",
         },
         providerAccount: {
           type: 'object',
@@ -350,6 +375,11 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           maximum: 86400,
           description: 'set_local_idle_ttl: unload after this many idle seconds, 0 disables; default 3600.',
         },
+        minutes: {
+          type: 'integer',
+          enum: [...HEARTBEAT_INTERVAL_CHOICES],
+          description: `set_heartbeat_interval: minutes between Mixy's heartbeat checks; default ${DEFAULT_HEARTBEAT_INTERVAL_MINUTES}.`,
+        },
         query: { type: 'string', description: 'search_local_models: Hugging Face GGUF search query.' },
         repository: { type: 'string', description: 'inspect_hf_model: public Hugging Face owner/model repository.' },
         filename: {
@@ -427,6 +457,35 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           },
           description: 'set_worktree_settings: only the given fields change.',
         },
+        sessionId: {
+          type: 'string',
+          description:
+            'reset_route_fallback (default: this session), continue_in_model, schedule_quota_resume, cancel_quota_resume: session id from status model/agents or the session tool. The last three take another session.',
+        },
+        actionKind: {
+          type: 'string',
+          enum: [...ACTION_KINDS],
+          description: "set_agent_permission: the action kind row of the agent's permission table.",
+        },
+        permissionMode: {
+          type: 'string',
+          enum: [...PERMISSION_MODES],
+          description:
+            'set_agent_permission: block or ask; allow (and any change that lets an agent do more without asking) is made by the person in the desktop app.',
+        },
+        tool: { type: 'string', description: 'set_agent_connector_tool: tool name within the connector `name`.' },
+        permission: {
+          type: 'string',
+          enum: [...CONNECTOR_PERMISSIONS],
+          description: 'set_agent_connector_tool: needs_approval or disabled; auto is made in the desktop app.',
+        },
+        botOrder: {
+          type: 'array',
+          items: { type: 'string', minLength: 1, pattern: '\\S' },
+          maxItems: 500,
+          description:
+            'set_bot_order: bot ids in display order (Mixy is always first and not listed); [] = default order.',
+        },
         ...SETUP_EXTENDED_PROPERTIES,
       },
     },

package/src/session-runtime/tool-policy/agent-profile-fold.mjs

@@ -19,6 +19,8 @@ import {
 } from '../../runtime/agent/orchestrator/mcp/agent-connectors.mjs';
 import { agentListEntries } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { markToolSurfaceMigrated } from '../../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
+import { resetBp2StableContext } from '../../runtime/agent/orchestrator/context/collect.mjs';
+import { requestPrefixIdentity } from '../../runtime/agent/orchestrator/session/thinking-binding.mjs';
 import {
   agentProfileRevision,
   leadRosterRevision,
@@ -40,15 +42,6 @@ const PROMPT_FOLD_INTENT = 'prompt_fold';
 // Cache-break intents that already rebuild the conversation's cached prefix.
 const COLD_INTENTS = new Set(['post_turn_compaction', 'manual_compaction']);
 
-// What the next request sends ahead of the conversation: the system blocks and tools.
-const promptPrefix = (session) =>
-  JSON.stringify([
-    (Array.isArray(session.messages) ? session.messages : [])
-      .filter((message) => message?.role === 'system')
-      .map((message) => message.content),
-    session.tools,
-  ]);
-
 // A bot thread built from other shipped rules than these (a release changed one).
 const rulesStale = (session) =>
   sessionModeOf(session) === AGENT_MODE && session.rulesRevision !== promptRulesRevision();
@@ -208,7 +201,10 @@ export function createAgentProfileFold({
     const config = configForSession(getConfig(), session.workflow?.id, currentMode(session));
     const staged = await stagePolicy(session, identity, config, { conversation: true });
     if (getSession?.() !== session) return false;
-    const before = promptPrefix(session);
+    const before = requestPrefixIdentity(session);
+    // BP2 (profile meta, skill manifest) from current sources too; applyPolicy
+    // re-appends its deferred manifest.
+    if (typeof staged.stableContext === 'string') resetBp2StableContext(session, staged.stableContext);
     applyPolicy(session, staged);
     rewriteConversationBp3Core(session, staged.core);
     if (session.agentProfileRevision !== undefined) {
@@ -218,17 +214,25 @@ export function createAgentProfileFold({
     }
     if (agentMode) session.rulesRevision = promptRulesRevision();
     session.updatedAt = Date.now();
-    if (promptPrefix(session) === before) return false;
+    if (requestPrefixIdentity(session) === before) return false;
     markToolSurfaceMigrated(session, session.pendingCacheBreakIntent || intent);
     return true;
   }
 
   /** Fold pending prompt changes (a switched workflow, a bot's moved tool
-   *  gates, changed shipped rules) when the cache is cold anyway. */
+   *  gates, changed shipped rules) when the cache is cold anyway. A
+   *  compaction rebuilds the prompt from current sources whether or not
+   *  anything is known pending (an update can change shipped rules, skills
+   *  and manifests no stamp tracks); an unchanged prompt stays byte-identical
+   *  and adds no break. */
   async function foldPromptIfCold() {
     const session = getSession?.();
+    // Scope exception: delegated worker sessions (`owner: 'agent'`) keep the
+    // prompt they were created with; they are task-scoped, and their skill
+    // bodies are still restored from current sources at Compact.
     if (!session?.id || !session.promptIdentity || isAgentOwner(session)) return false;
-    if (!foldPending(session) || !cacheCold(session)) return false;
+    const compacted = COLD_INTENTS.has(session.pendingCacheBreakIntent);
+    if (!compacted && !(foldPending(session) && cacheCold(session))) return false;
     return foldPrompt(session, PROMPT_FOLD_INTENT);
   }
 

package/src/session-runtime/tool-policy/policy-stage.mjs

@@ -11,9 +11,14 @@ import {
 import { deferredSurfaceModeForLead } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import {
   applyInitialDeferredToolManifestToBp2,
+  buildSkillManifest,
+  collectPromptSkillsCached,
   composeSystemPrompt,
 } from '../../runtime/agent/orchestrator/context/collect.mjs';
-import { _buildBaseRules } from '../../runtime/agent/orchestrator/session/manager/rules-cache.mjs';
+import {
+  _buildBaseRules,
+  _buildLeadMetaContext,
+} from '../../runtime/agent/orchestrator/session/manager/rules-cache.mjs';
 import { sessionRolePromptFields } from '../../runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs';
 import {
   delegationDisabled,
@@ -130,11 +135,17 @@ export function createPolicyStage({
         : _buildBaseRules({
             omitTools: [...denied, unusedModelEditToolName(getRoute()?.model)],
             allowTools: schemaAllowedTools,
+            ownerIsAgent,
             provider: getRoute()?.provider,
             model: getRoute()?.model,
           });
     const coreMemoryContext = conversation ? '' : await leadCoreMemoryContext();
-    const { sessionMarkerCore } = composeSystemPrompt({
+    // BP2's stable part as session creation composes it
+    // (session-prompt-composition.mjs): the Lead meta context and the skill
+    // manifest of the skills in scope now.
+    const skipRules = identity.skipAgentRules || toolFreeRole;
+    const skills = schemaAllowedTools?.length === 0 ? [] : collectPromptSkillsCached(session.cwd);
+    const { sessionMarkerCore, stableSystemContext } = composeSystemPrompt({
       ...sessionRolePromptFields(identity, {
         ownerIsAgent,
         toolFreeRole,
@@ -149,6 +160,8 @@ export function createPolicyStage({
       // setting; agent mode carries none.
       instructionFilesContext:
         conversation || toolFreeRole || agentMode ? null : loadInstructionFilesContext?.(session) || null,
+      metaContext: skipRules || ownerIsAgent ? undefined : _buildLeadMetaContext({ includeOutputStyle: !agentMode }),
+      skillManifest: buildSkillManifest(skills),
     });
     return {
       workflow,
@@ -159,6 +172,8 @@ export function createPolicyStage({
       ownerIsAgent,
       baseRules,
       core: conversation ? withPresentedWorkspaceSlices(session, sessionMarkerCore) : sessionMarkerCore,
+      // Without BP1 the BP2 block cannot be located: null leaves it as it is.
+      stableContext: skipRules ? null : stableSystemContext,
     };
   }
 

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

@@ -80,6 +80,7 @@ export function createAskCallbacks({ transcript, notifyFnForSession, scheduleSea
       beforeToolExecution: () => turn.snapshot.promise || Promise.resolve(),
       transcriptMeta: stampCheckpoint(options),
       promptSource: options.promptSource,
+      ...(options.promptOrigin ? { promptOrigin: options.promptOrigin } : {}),
       // A routine turn's trusted selection text (its instructions only).
       ...(typeof options.skillSelection === 'string' ? { skillSelection: options.skillSelection } : {}),
       retryFailedTurn: options.retryFailedTurn === true,

package/src/session-runtime/workflow-agents-api/agent-editor.mjs

@@ -19,7 +19,11 @@ import {
   writeJsonAtomicSync,
 } from '../../runtime/shared/atomic-file.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
-import { agentEntryFile, agentEntryPath, parseManifestText } from '../../runtime/agent/orchestrator/runtime-core/workflow/agents.mjs';
+import {
+  agentEntryFile,
+  agentEntryPath,
+  parseManifestText,
+} from '../../runtime/agent/orchestrator/runtime-core/workflow/agents.mjs';
 import { hasOwn } from '../../runtime/shared/object.mjs';
 import { serializeFrontmatterDoc } from '../../runtime/shared/markdown-frontmatter.mjs';
 import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.mjs';

package/src/session-runtime/workflow-agents-api/agent-route.mjs

@@ -22,7 +22,11 @@ import {
 
 /** Mixy's runtime id (agent-home.mjs MIXY_AGENT_ID). */
 const MIXY_RUNTIME_ID = 'lead';
-import { routeChain, validateRouteChainProviders } from '../../runtime/shared/model-route-chain.mjs';
+import {
+  canonicalRouteProvider,
+  routeChain,
+  validateRouteChainProviders,
+} from '../../runtime/shared/model-route-chain.mjs';
 
 // Agent route persistence. Route-scope isolation: an agent route owns its
 // model AND its effort/fast, stored in config.agents[<id>]. The shared
@@ -183,18 +187,25 @@ export function createAgentRouteApi(deps) {
     }
     if (!clean(requested.provider)) return clearOverride(id);
     if (!clean(requested.model)) throw new Error('agent route requires provider and model');
+    // An explicit list is validated; the stored one may hold a fallback on the
+    // picked model's provider, which stays saved untouched and inactive.
+    const explicitFallbacks = hasOwn(requested, 'fallbacks');
     const chain = routeChain({
       ...requested,
-      fallbacks: hasOwn(requested, 'fallbacks') ? requested.fallbacks : stored.fallbacks,
+      fallbacks: explicitFallbacks ? requested.fallbacks : stored.fallbacks,
     });
-    validateRouteChainProviders(chain);
+    validateRouteChainProviders(chain, { allowDuplicates: !explicitFallbacks });
     const storedChain = routeChain(stored);
     const resolved = [];
+    const usedProviders = new Set();
     for (const entry of chain) {
+      const provider = canonicalRouteProvider(entry.provider);
+      const inactive = usedProviders.has(provider);
+      usedProviders.add(provider);
       const previous = storedChain.find(
         (candidate) => candidate.provider === entry.provider && candidate.model === entry.model
       );
-      resolved.push(await resolveChainEntry(deps, entry, previous || {}));
+      resolved.push(inactive ? entry : await resolveChainEntry(deps, entry, previous || {}));
     }
     const [primary, ...fallbacks] = resolved;
     const routeToSave = normalizeWorkflowRoute({ ...primary, fallbacks });

package/src/session-runtime/workflow-agents-api/onboarding.mjs

@@ -20,7 +20,7 @@ import { resolveDataDir } from './shared.mjs';
 function applyWorkflowSlots(workflowInput, draft) {
   for (const slot of WORKFLOW_ROUTE_SLOTS) {
     if (!hasOwn(workflowInput, slot)) continue;
-    const normalized = normalizeWorkflowRoute(workflowInput[slot]);
+    const normalized = normalizeWorkflowRoute(workflowInput[slot], {}, { strict: true });
     if (slot === 'lead') {
       if (!normalized) continue;
       draft.presets = upsertWorkflowPreset(draft.presets, 'lead', normalized);
@@ -40,7 +40,7 @@ function applyAgentRouteInput(agentInput, agentRoutes, configurableIds) {
   const nextAgents = { ...agentRoutes };
   for (const id of configurableIds) {
     if (!hasOwn(agentInput, id)) continue;
-    const routeToSave = normalizeWorkflowRoute(agentInput[id]);
+    const routeToSave = normalizeWorkflowRoute(agentInput[id], {}, { strict: true });
     if (routeToSave) nextAgents[id] = routeToSave;
     else delete nextAgents[id];
   }
@@ -67,7 +67,7 @@ export function createOnboardingApi(deps) {
       const config = getConfig();
       const nextConfig = { ...config };
       const defaultRoute = hasOwn(payload, 'defaultRoute')
-        ? normalizeWorkflowRoute(payload.defaultRoute, getRoute())
+        ? normalizeWorkflowRoute(payload.defaultRoute, getRoute(), { strict: true })
         : null;
       const draft = {
         presets: Array.isArray(nextConfig.presets) ? nextConfig.presets.slice() : [],

package/src/session-runtime/workflow-agents-api/style-and-mode.mjs

@@ -64,6 +64,10 @@ export function createStyleAndModeApi(deps) {
     listOutputStyles: () => getOutputStyleStatusCached(),
     setOutputStyle,
     getOrchestrationMode: () => configuredOrchestrationMode(displayConfig()),
+    // The default new sessions inherit. The runtime facade's own
+    // getOrchestrationMode answers for the ACTIVE session when one exists, so a
+    // New Task composer reads this one: it never depends on which session is open.
+    getConfiguredOrchestrationMode: () => configuredOrchestrationMode(displayConfig()),
     setOrchestrationMode,
   };
 }

package/src/session-runtime/workspace/transitions.mjs

@@ -752,6 +752,30 @@ export function createWorkspaceTransitions({
     return maintenance.pruneWorktrees({ ...(await maintenanceScope()), repoCommonDir });
   }
 
+  /**
+   * Remove managed worktree `entryId` whose owner is gone (listed `ownerLive:
+   * false, removable: true`), on an explicit request: no owner lane exists to
+   * do it. No stored or live session may still use the folder; the manager
+   * reads the retention again under the repository lock (an owner that came
+   * back refuses) and keeps its guards: dirty or unmerged work needs `force`,
+   * other sessions' references and retained recovery data refuse, and only
+   * the managed checkout is deleted.
+   */
+  async function removeOrphanWorktree({ entryId, force = false } = {}) {
+    const row = (await listWorktrees()).find((item) => item.id === entryId);
+    if (!row) throw worktreeError('WORKTREE_MISSING', undefined, { entryId });
+    const removed = await withManagementFolders([row.path], true, async () => {
+      const { liveSessionIds, listSessionIds, manager: backendApi } = await maintenanceScope();
+      return backendApi.removeOrphanedWorktree({
+        entryId,
+        force: force === true,
+        liveSessionIds,
+        retainedSessionIds: await listSessionIds(),
+      });
+    });
+    return { removed, entryId, path: row.path };
+  }
+
   /** After `sessionId` was deleted: autoCleanup removes its clean, merged worktree. */
   async function cleanupDeletedSession(sessionId) {
     // Its snapshots go with it below; no turn cleanup keeps retrying them.
@@ -1219,6 +1243,7 @@ export function createWorkspaceTransitions({
     switchProject,
     listWorktrees,
     pruneWorktrees,
+    removeOrphanWorktree,
     cleanupDeletedSession,
     onWorktreeSetup,
     dispose,

package/src/session-runtime/workspace/worktree-tool.mjs

@@ -27,12 +27,7 @@ const loadManager = () => import('../../runtime/shared/worktrees/manager.mjs');
  * @param {((args: object, context: object) => Promise<any>)|null} [deps.executeSessionControl] Cross-session lane.
  * @param {object|null} [deps.manager] Managed-worktree backend override (tests).
  */
-export function createWorktreeToolHost({
-  getSession,
-  getWorkspaceApi,
-  executeSessionControl = null,
-  manager = null,
-}) {
+export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSessionControl = null, manager = null }) {
   const backend = () => (manager ? Promise.resolve(manager) : loadManager());
 
   function workspaceApi() {
@@ -102,7 +97,11 @@ export function createWorktreeToolHost({
         'The project folder has no checked-out branch to return to (detached HEAD).'
       );
     }
-    return lane.call('selectBranch', { branch: projectBranch, expectedRevision: workspace.revision, txId: request.txId });
+    return lane.call('selectBranch', {
+      branch: projectBranch,
+      expectedRevision: workspace.revision,
+      txId: request.txId,
+    });
   }
 
   /** The desktop's "merge": into the confirmed merge target, then the cleanup autoCleanup allows. */
@@ -116,6 +115,15 @@ export function createWorktreeToolHost({
     });
   }
 
+  /**
+   * The listed worktree matching `predicate` whose owner is gone and that the
+   * list reports removable, or null: no owner lane can remove it.
+   */
+  async function orphan(predicate) {
+    const rows = await workspaceApi().listWorktrees();
+    return rows.find((row) => predicate(row) && row.ownerLive === false && row.removable === true) ?? null;
+  }
+
   /**
    * `git worktree remove <path>`: the managed removal of whichever owner
    * holds it — this session's snapshot, or the worktree a session retains
@@ -129,6 +137,9 @@ export function createWorktreeToolHost({
       );
     }
     if (entry.kind === 'snapshot') return workspaceApi().removeSnapshot({ path: entry.path, force: request.force });
+    if (entry.ownerSessionId !== callerSessionId && (await orphan((row) => row.id === entry.id))) {
+      return workspaceApi().removeOrphanWorktree({ entryId: entry.id, force: request.force === true });
+    }
     if (!entry.ownerSessionId) {
       throw new Error(
         `git worktree remove: no session retains ${entry.path}; git worktree prune removes it once it is clean and merged`
@@ -161,8 +172,14 @@ export function createWorktreeToolHost({
         return back(lane(), request);
       case 'merge':
         return merge(lane());
-      case 'remove':
-        return lane().call('removeWorktree', { force: request.force === true });
+      case 'remove': {
+        const force = request.force === true;
+        if (request.sessionId && request.sessionId !== callerSessionId) {
+          const gone = await orphan((row) => row.ownerSessionId === request.sessionId);
+          if (gone) return workspaceApi().removeOrphanWorktree({ entryId: gone.id, force });
+        }
+        return lane().call('removeWorktree', { force });
+      }
       case 'list':
         return workspaceApi().listWorktrees({ includeSnapshots: true });
       case 'prune':