mixdog 1.3.1 → 1.3.3

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

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from 'node:util';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { hasOwn } from '../../runtime/shared/object.mjs';
 import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.mjs';
@@ -10,6 +11,7 @@ import {
   withAgentDisabled,
 } from '../../runtime/shared/agent-route-config.mjs';
 import { agentEditorId, resolveDataDir } from './shared.mjs';
+import { publishAgentRouteChange } from '../agent-profile-changes.mjs';
 import {
   isStoreBot,
   readBotRoute,
@@ -29,9 +31,52 @@ import { routeChain, validateRouteChainProviders } from '../../runtime/shared/mo
 // lead preset, so an agent that reused it silently rewrote Main's effort/fast
 // for the next session. The agent's own stored route is the fallback instead,
 // and the bucket is never written here.
+// Tuning-only edits keep the stored model's effort/fast/modelParameters;
+// a model change starts from the resolved defaults. Fast is then clamped
+// to what the selected model supports. The ONE normalizer of a chain entry:
+// agents, bots, Mixy and the Lead's fallbacks all pass through it.
+export async function resolveChainEntry(deps, requested, stored) {
+  const { getConfig, resolveRoute, lookupModelMeta, ensureProvidersReady } = deps;
+  let selectedRoute = resolveRoute(getConfig(), requested);
+  const sameModel =
+    clean(selectedRoute.provider) === clean(stored.provider) && clean(selectedRoute.model) === clean(stored.model);
+  const inheritedEffort = sameModel ? stored.effort || null : null;
+  const inheritedModelParameters = sameModel ? stored.modelParameters || {} : {};
+  // A requested percent replaces the stored exact window and requested
+  // tokens replace the stored percent.
+  const requestsPercent = requested.contextPercent !== undefined;
+  const requestsTokens = requested.contextTokens !== undefined;
+  const inheritedContextPercent = sameModel && !requestsTokens ? stored.contextPercent : undefined;
+  const inheritedContextTokens = sameModel && !requestsPercent ? stored.contextTokens : undefined;
+  selectedRoute = {
+    ...selectedRoute,
+    effort: requested.effort !== undefined ? selectedRoute.effort : inheritedEffort,
+    fast: requested.fast !== undefined ? selectedRoute.fast === true : sameModel && stored.fast === true,
+    // Main's modelSettings bucket must not decide an agent's Auto effort.
+    autoEffort:
+      requested.autoEffort !== undefined ? requested.autoEffort !== false : !sameModel || stored.autoEffort !== false,
+    modelParameters: requested.modelParameters !== undefined ? selectedRoute.modelParameters : inheritedModelParameters,
+    // resolveRoute reads contextPercent from Main's modelSettings bucket;
+    // an agent route owns its own.
+    contextPercent: requestsPercent ? requested.contextPercent : inheritedContextPercent,
+    contextTokens: requestsTokens ? requested.contextTokens : inheritedContextTokens,
+  };
+  await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+  const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+  // Stored clamped, and not at all at the default window, as for Main.
+  const contextState = resolveRouteContextState(selectedRoute, modelMeta);
+  if (contextState.contextDefaultPercent !== undefined) selectedRoute.contextTokens = contextState.contextTokens;
+  const fastCapable = selectionFastCapable(
+    selectedRoute.provider,
+    modelMeta,
+    selectedRoute.effort,
+    selectedRoute.modelParameters
+  );
+  return { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
+}
+
 export function createAgentRouteApi(deps) {
-  const { getConfig, resolveRoute, lookupModelMeta, saveConfigAndAdopt, ensureProvidersReady, agentRouteFromConfig } =
-    deps;
+  const { getConfig, resolveRoute, saveConfigAndAdopt, agentRouteFromConfig } = deps;
 
   function saveDisabled(id, disabled) {
     saveConfigAndAdopt(canonicalizeAgentRouteStorage(withAgentDisabled(getConfig(), id, disabled)));
@@ -58,67 +103,41 @@ export function createAgentRouteApi(deps) {
     saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
   }
 
+  // The route a bot saved of its own ({} when none).
+  function ownRoute(id) {
+    if (isMixy(id)) return readMixyRoute(dataDir()) || {};
+    if (storeBot(id)) return readBotRoute(dataDir(), id) || {};
+    return agentRouteFromConfig(getConfig(), id) || {};
+  }
+  // The route a bot's chats run on: its own, else Main's.
+  const chatRoute = (id) => {
+    const own = ownRoute(id);
+    return normalizeWorkflowRoute(own.provider ? own : resolveRoute(getConfig(), {}));
+  };
+  // Structural, so equivalent parameter objects in another key order are the same route.
+  const plainRoute = (route) => JSON.parse(JSON.stringify(normalizeWorkflowRoute(route) ?? null));
+  const sameRoute = (a, b) => isDeepStrictEqual(plainRoute(a), plainRoute(b));
+
   // Only an explicitly empty provider removes an override: the agent inherits Main.
-  function clearOverride(id) {
+  async function clearOverride(id) {
+    const before = chatRoute(id);
     if (isMixy(id) || storeBot(id)) {
       if (isMixy(id)) writeMixyRoute(dataDir(), null);
       else writeBotRoute(dataDir(), id, null);
-      const inherited = normalizeWorkflowRoute(resolveRoute(getConfig(), {}));
-      return { ...(inherited || {}), inherited: true };
+    } else {
+      const nextConfig = { ...getConfig() };
+      const agents = { ...(nextConfig.agents || {}) };
+      const hadOverride = Object.hasOwn(agents, id);
+      delete agents[id];
+      nextConfig.agents = agents;
+      if (hadOverride) saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
     }
-    const nextConfig = { ...getConfig() };
-    const agents = { ...(nextConfig.agents || {}) };
-    const hadOverride = Object.hasOwn(agents, id);
-    delete agents[id];
-    nextConfig.agents = agents;
-    if (hadOverride) saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
     const inherited = normalizeWorkflowRoute(resolveRoute(getConfig(), {}));
+    // The bot's chats follow Main from their next turn (unless they already do).
+    if (inherited && !sameRoute(before, inherited)) await publishAgentRouteChange(id, inherited);
     return { ...(inherited || {}), inherited: true };
   }
 
-  // Tuning-only edits keep the stored model's effort/fast/modelParameters;
-  // a model change starts from the resolved defaults. Fast is then clamped
-  // to what the selected model supports.
-  async function resolveSelectedRoute(requested, stored) {
-    let selectedRoute = resolveRoute(getConfig(), requested);
-    const sameModel =
-      clean(selectedRoute.provider) === clean(stored.provider) && clean(selectedRoute.model) === clean(stored.model);
-    const inheritedEffort = sameModel ? stored.effort || null : null;
-    const inheritedModelParameters = sameModel ? stored.modelParameters || {} : {};
-    // A requested percent replaces the stored exact window and requested
-    // tokens replace the stored percent.
-    const requestsPercent = requested.contextPercent !== undefined;
-    const requestsTokens = requested.contextTokens !== undefined;
-    const inheritedContextPercent = sameModel && !requestsTokens ? stored.contextPercent : undefined;
-    const inheritedContextTokens = sameModel && !requestsPercent ? stored.contextTokens : undefined;
-    selectedRoute = {
-      ...selectedRoute,
-      effort: requested.effort !== undefined ? selectedRoute.effort : inheritedEffort,
-      fast: requested.fast !== undefined ? selectedRoute.fast === true : sameModel && stored.fast === true,
-      // Main's modelSettings bucket must not decide an agent's Auto effort.
-      autoEffort:
-        requested.autoEffort !== undefined ? requested.autoEffort !== false : !sameModel || stored.autoEffort !== false,
-      modelParameters:
-        requested.modelParameters !== undefined ? selectedRoute.modelParameters : inheritedModelParameters,
-      // resolveRoute reads contextPercent from Main's modelSettings bucket;
-      // an agent route owns its own.
-      contextPercent: requestsPercent ? requested.contextPercent : inheritedContextPercent,
-      contextTokens: requestsTokens ? requested.contextTokens : inheritedContextTokens,
-    };
-    await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
-    const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
-    // Stored clamped, and not at all at the default window, as for Main.
-    const contextState = resolveRouteContextState(selectedRoute, modelMeta);
-    if (contextState.contextDefaultPercent !== undefined) selectedRoute.contextTokens = contextState.contextTokens;
-    const fastCapable = selectionFastCapable(
-      selectedRoute.provider,
-      modelMeta,
-      selectedRoute.effort,
-      selectedRoute.modelParameters
-    );
-    return { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
-  }
-
   async function setAgentRoute(agentId, next) {
     const id = agentEditorId(agentId);
     if (!id) throw new Error(`unknown agent "${agentId}"`);
@@ -128,16 +147,16 @@ export function createAgentRouteApi(deps) {
     // picked while the model resolved below stays (answered with `skipped`).
     const onlyIfEmpty = requested.onlyIfEmpty === true;
     delete requested.onlyIfEmpty;
-    const readStored = () => {
-      if (isMixy(id)) return readMixyRoute(dataDir()) || {};
-      if (storeBot(id)) return readBotRoute(dataDir(), id) || {};
-      return agentRouteFromConfig(getConfig(), id) || {};
-    };
+    const readStored = () => ownRoute(id);
     const kept = () => ({ ...readStored(), id, skipped: true });
     const stored = readStored();
     if (onlyIfEmpty && clean(stored.provider)) return kept();
-    // Mixy is never off: its route request is a model pick alone.
-    if (isMixy(id)) delete requested.disabled;
+    // Mixy is never off: its route request is a model pick alone, and an
+    // on/off request alone changes nothing.
+    if (isMixy(id) && hasOwn(requested, 'disabled')) {
+      delete requested.disabled;
+      if (!Object.keys(requested).length) return { ...stored, id };
+    }
     // Off is an explicit state, stored apart from the route so the model the
     // user picked survives and comes back when the agent is switched on. An
     // off request that also carries a model saves that model and stays off.
@@ -147,7 +166,7 @@ export function createAgentRouteApi(deps) {
       // An explicitly empty provider still asks to drop the override, as it
       // does for an agent that stays on: off and inheriting Main.
       if (hasOwn(requested, 'provider') && !clean(requested.provider)) {
-        return { ...clearOverride(id), id, disabled: true };
+        return { ...(await clearOverride(id)), id, disabled: true };
       }
       return { ...stored, id, disabled: true };
     }
@@ -175,7 +194,7 @@ export function createAgentRouteApi(deps) {
       const previous = storedChain.find(
         (candidate) => candidate.provider === entry.provider && candidate.model === entry.model
       );
-      resolved.push(await resolveSelectedRoute(entry, previous || {}));
+      resolved.push(await resolveChainEntry(deps, entry, previous || {}));
     }
     const [primary, ...fallbacks] = resolved;
     const routeToSave = normalizeWorkflowRoute({ ...primary, fallbacks });
@@ -189,7 +208,10 @@ export function createAgentRouteApi(deps) {
     if (onlyIfEmpty && clean(readStored().provider)) return kept();
     const stayOff = onlyIfEmpty ? isAgentDisabled(getConfig(), id) : keepOff;
     // Picking a model is also the "on" switch unless the request keeps it off.
+    const before = chatRoute(id);
     saveRoute(id, routeToSave, stayOff);
+    // The bot's existing chats move onto it from their next turn (unless they already run it).
+    if (!sameRoute(before, routeToSave)) await publishAgentRouteChange(id, routeToSave);
     return stayOff ? { ...routeToSave, id, disabled: true } : routeToSave;
   }
 

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

@@ -1,5 +1,9 @@
 import { oneLine } from '../../runtime/shared/clean.mjs';
-import { normalizeAgentId, normalizeWorkflowId, normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import {
+  normalizeAgentId,
+  normalizeWorkflowId,
+  normalizeWorkflowRoute,
+} from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 
 export function resolveDataDir({ cfgMod, STANDALONE_DATA_DIR }) {
   return cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;

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

@@ -35,10 +35,23 @@ export function createStyleAndModeApi(deps) {
     return { ...freshStatus, appliedToCurrentSession };
   }
 
-  async function setOrchestrationMode(mode) {
+  // `{ scope: 'session' }` (the composer's selector in a session), like
+  // setWorkflow: a session with a conversation switches alone
+  // (switchSessionOrchestrationMode; deferred to its next turn while one
+  // runs) and the configured mode — the default for new sessions — stays.
+  // Otherwise the choice becomes the configured mode and an empty session
+  // picks it up in place.
+  async function setOrchestrationMode(mode, options = {}) {
     if (!ORCHESTRATION_MODES.includes(mode)) {
       throw new Error(`orchestration mode must be one of ${ORCHESTRATION_MODES.join(', ')}`);
     }
+    if (options?.scope === 'session') {
+      const switched = await deps.switchSessionOrchestrationMode?.(mode);
+      if (switched) {
+        invalidateContextStatusCache();
+        return switched;
+      }
+    }
     saveConfigAndAdopt({ ...getConfig(), orchestrationMode: mode });
     const applied = await deps.refreshEmptySessionToolPolicy?.();
     deps.invalidatePreSessionToolSurface?.();

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

@@ -1,5 +1,6 @@
 import { join } from 'node:path';
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { writeFileAtomicSync } from '../../runtime/shared/atomic-file.mjs';
 import { serializeFrontmatterDoc } from '../../runtime/shared/markdown-frontmatter.mjs';
 import {
   normalizeWorkflowId,
@@ -44,6 +45,7 @@ export function createWorkflowPacksApi(deps) {
       name: workflow.name,
       description: workflow.description,
       source: workflow.source,
+      ...(workflow.overridesBuiltIn ? { overridesBuiltIn: true } : {}),
       active: workflow.id === active,
     }));
   }
@@ -106,9 +108,10 @@ export function createWorkflowPacksApi(deps) {
     if (!absorbed) {
       const dir = join(dataDir, 'workflows', id);
       mkdirSync(dir, { recursive: true });
-      writeFileSync(
+      writeFileAtomicSync(
         join(dir, 'WORKFLOW.md'),
-        serializeFrontmatterDoc({ id, name, ...(description ? { description } : {}) }, body)
+        serializeFrontmatterDoc({ id, name, ...(description ? { description } : {}) }, body),
+        { backup: true, mode: 0o644 }
       );
     }
     return getWorkflowPack(id);

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

@@ -251,7 +251,6 @@ export function createTransitionSteps({
     const projectPath = previous.projectPath;
     const project = await inspectProject(projectPath, { signal });
     let entry = await backendApi.getSessionWorktree(session.id);
-    const created = !entry;
     if (entry) {
       if (!existsSync(entry.path)) {
         throw worktreeError('WORKTREE_MISSING', undefined, { worktreeId: entry.id, path: entry.path });
@@ -333,18 +332,9 @@ export function createTransitionSteps({
       await backendApi.dropCarryRecoveryRef({ projectPath, recoveryRef: entry.changes.recoveryRef }).catch(() => {});
     }
     // Creation notes (submodules, include entries missing or already present).
-    // `created`: a new checkout, whose first-turn preparation still awaits
-    // (`prepared`: what creation did and what the turn still has to run).
+    // A new checkout's first-turn preparation stays pending in its registry entry.
     return {
       ...entered,
-      ...(created
-        ? {
-            created: {
-              prepared: entry.prepared ?? null,
-              root: entry.prepared?.root || project.topLevel || projectPath,
-            },
-          }
-        : {}),
       warnings: Array.isArray(entry.warnings) ? [...entry.warnings] : [],
       ...(entry.changes ? { changes: { mode: entry.changes.mode, count: entry.changes.count } } : {}),
     };
@@ -395,13 +385,6 @@ export function createTransitionSteps({
       journal.push(() => backendApi.claimWorktreeOwner(previous.worktreeId, owner(session.id)));
       await releaseOwner(backendApi, previous.worktreeId, session.id, { forgetReference: true });
     }
-    // A managed worktree made for the branch: its first-turn preparation awaits.
-    if (resolved.created === true && entry) {
-      return {
-        ...result,
-        created: { prepared: entry.prepared ?? null, root: entry.prepared?.root || project.topLevel || projectPath },
-      };
-    }
     return result;
   }