mixdog 1.3.1 → 1.3.2

package/src/tui/session/session-api/routes.mjs

@@ -4,88 +4,20 @@
  * definitions, output style and orchestration mode.
  */
 import {
-  modelSwitchItem,
+  orchestrationModeSwitchItem,
   workflowSwitchItem,
 } from '../../../runtime/agent/orchestrator/session/transcript-restore/restore.mjs';
-import { selectedModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
+import { createAgentDefinitionApi } from './routes-agent-definitions.mjs';
+import { createRouteWrite } from './routes-write.mjs';
 import { createApiHelpers } from './shared.mjs';
 
-// Optimistic route preview: the requested provider/model/effort/fast are
-// published before the runtime write settles. What is NOT previewed about the
-// route (effort options, Fast capability, context window) is provider
-// metadata the runtime resolves while the preview is already on screen.
-const ROUTE_PREVIEW_KEYS = [
-  'provider',
-  'model',
-  'effort',
-  'fast',
-  'autoEffort',
-  'modelParameters',
-  'contextPercent',
-  'contextTokens',
-];
+export { publishModelSwitch } from './routes-write.mjs';
 
-/**
- * The patch that publishes a requested route before the runtime write settles.
- * Returns null when the request carries nothing previewable.
- */
-function optimisticRoutePatch(requested = {}, current = {}) {
-  const route = requested && typeof requested === 'object' ? requested : {};
-  const has = (key) => Object.hasOwn(route, key);
-  const patch = {};
-  for (const key of ROUTE_PREVIEW_KEYS) {
-    if (has(key)) patch[key] = route[key];
-  }
-  if (!has('provider') && !has('model')) {
-    return Object.keys(patch).length > 0 ? patch : null;
-  }
-  const sameModel =
-    String(patch.provider ?? current.provider ?? '') === String(current.provider ?? '') &&
-    String(patch.model ?? current.model ?? '') === String(current.model ?? '');
-  // A different model carries none of the previous model's tuning: an omitted
-  // key means "this model has no such control", not "keep the old value".
-  if (!sameModel) {
-    if (!has('effort')) patch.effort = null;
-    if (!has('fast')) patch.fast = false;
-    if (!has('modelParameters')) patch.modelParameters = {};
-  }
-  return patch;
-}
-
-const SESSION_ONLY_KEYS = new Set(['provider', 'model', 'effort', 'fast', 'autoEffort']);
-
-/**
- * A session-only request (an agent child's route) may name just the model, just
- * the tuning, or both. Completed here, inside the serialized route write,
- * against the latest selected route — so a Fast-only change keeps the effort a
- * previous write selected. `unchanged` when it asks for nothing the selected
- * route does not already have.
- */
-function completeSessionOnlyRequest(request, selected) {
-  const named = Boolean(request.provider || request.model);
-  const target = named ? request : { ...request, provider: selected.provider, model: selected.model };
-  const sameModel = target.provider === selected.provider && target.model === selected.model;
-  if (!sameModel) return { request: target, unchanged: false };
-  const unchanged =
-    Object.keys(request).every((key) => SESSION_ONLY_KEYS.has(key)) &&
-    (request.effort === undefined || request.effort === selected.effort) &&
-    (request.fast === undefined || request.fast === (selected.fast === true)) &&
-    (request.autoEffort === undefined || request.autoEffort === (selected.autoEffort !== false));
-  return {
-    unchanged,
-    request: {
-      ...(selected.effort ? { effort: selected.effort } : {}),
-      fast: selected.fast === true,
-      autoEffort: selected.autoEffort !== false,
-      ...target,
-    },
-  };
-}
-
-/** The live divider of an in-place model switch (restored from message meta
- *  after a reload); every switch path publishes it the same way. */
-export function publishModelSwitch(bag, modelSwitch) {
-  if (modelSwitch) bag.pushItem(modelSwitchItem(bag.nextId(), modelSwitch));
+/** The live dividers of a conversation's orchestration mode and workflow
+ *  switches (made now, or chosen during a turn and applied at the next). */
+export function publishSessionSwitches(bag, { orchestrationModeSwitch, workflowSwitch } = {}) {
+  if (orchestrationModeSwitch) bag.pushItem(orchestrationModeSwitchItem(bag.nextId(), orchestrationModeSwitch));
+  if (workflowSwitch) bag.pushItem(workflowSwitchItem(bag.nextId(), workflowSwitch));
 }
 
 export function createSessionRouteApi(bag) {
@@ -106,117 +38,15 @@ export function createSessionRouteApi(bag) {
     routeState,
     syncContextStats,
   });
-  let routeWrite = null;
-  let routeSequence = 0;
-  // Whether this API (not another command) is the one holding commandBusy.
-  let routeLocked = false;
-
-  // A preset selector previews as the preset's model, never as its id.
-  const previewedRequest = (routeOpts) => {
-    if (routeOpts.provider || !routeOpts.model) return routeOpts;
-    const target = selectedModel(runtime, routeOpts, '', '');
-    return target.provider ? { ...routeOpts, ...target } : routeOpts;
-  };
-
-  const setRoute = async (opts) => {
-    const routeOpts = opts && typeof opts === 'object' ? opts : {};
-    // All model pickers save a selection for the conversation's next turn; a
-    // running turn keeps the session model it started on. A selection is never
-    // refused: another command's lock neither blocks it nor is released by it.
-    const token = ++routeSequence;
-    const previousWrite = routeWrite;
-    // The session generation this selection was made under. The write below
-    // waits behind earlier ones, so "current" is never read later: the runtime
-    // validates this token before every route side effect, and `settle` below
-    // is the only place the display is touched once the write has started.
-    const originGeneration = runtime.sessionGeneration;
-    const owned = () => runtime.sessionGeneration === originGeneration;
-    // A conditional fill (only when the route is still empty) may not apply, so
-    // it never previews: the runtime's answer is what gets published.
-    const onlyIfEmpty = routeOpts.onlyIfEmpty === true;
-    const preview = onlyIfEmpty ? null : optimisticRoutePatch(previewedRequest(routeOpts), getState());
-    // Preview immediately, serialize persistence without dropping a later
-    // click. Earlier completions cannot replace the newest visible choice.
-    if (!getState().commandBusy) routeLocked = true;
-    set({ ...(routeLocked ? { commandBusy: true } : {}), ...(preview || {}) });
-    flushEmitImmediate();
-    const write = (async () => {
-      if (previousWrite) await previousWrite.catch(() => {});
-      const previousRoute = routeState();
-      // A stale selection only republishes the route that is actually
-      // selected; it never restores or announces its own session's state.
-      const settle = ({ failed = false, sync = false, modelSwitch = null } = {}) => {
-        const stillOwned = owned();
-        if (stillOwned) publishModelSwitch(bag, modelSwitch);
-        // A newer selection publishes the final route itself.
-        if (token !== routeSequence) return;
-        if (stillOwned && failed) {
-          if (preview) set({ ...previousRoute, stats: { ...getState().stats } });
-          return;
-        }
-        if (stillOwned && sync) syncContextStats({ allowEstimated: true });
-        publishRoute();
-      };
-      try {
-        // Keep the durable session address while deferring route application.
-        const applyToCurrentSession = routeOpts.applyToCurrentSession === true;
-        const keepMainModel = routeOpts.keepMainModel !== false;
-        const sessionOnly = routeOpts.sessionOnly === true;
-        const {
-          applyToCurrentSession: _drop,
-          keepMainModel: _keep,
-          sessionOnly: _scope,
-          onlyIfEmpty: _fill,
-          ...requested
-        } = routeOpts;
-        let nextRoute = requested;
-        if (sessionOnly) {
-          const completed = completeSessionOnlyRequest(requested, previousRoute);
-          if (completed.unchanged) {
-            // An earlier failed write skipped its rollback because this one is
-            // newer, so the shown route may still be that write's preview.
-            settle();
-            return previousRoute;
-          }
-          nextRoute = completed.request;
-        }
-        const resolvedRoute = await runtime.setRoute(nextRoute, {
-          applyToCurrentSession,
-          keepMainModel,
-          ...(sessionOnly ? { sessionOnly } : {}),
-          ...(onlyIfEmpty ? { onlyIfEmpty } : {}),
-          ...(originGeneration !== undefined ? { originGeneration } : {}),
-          switchEstablished: true,
-          deferUntilNextTurn: true,
-        });
-        settle({
-          sync: applyToCurrentSession || Boolean(resolvedRoute?.modelSwitch),
-          modelSwitch: resolvedRoute?.modelSwitch,
-        });
-        return resolvedRoute;
-      } catch (error) {
-        settle({ failed: true });
-        throw error;
-      } finally {
-        if (token === routeSequence) {
-          if (routeLocked) set({ commandBusy: false });
-          routeLocked = false;
-          // Publish the resolved route (or rollback) before an RPC reply
-          // reads getState(), even while the display-frame clock is busy.
-          flushEmitImmediate();
-        }
-      }
-    })();
-    routeWrite = write;
-    try {
-      return await write;
-    } finally {
-      if (routeWrite === write) routeWrite = null;
-    }
-  };
-  // The settings surface's setModel (/model, presets) is the same user
-  // model choice and runs through this one path.
-  bag.setSessionRoute = setRoute;
+  const setRoute = createRouteWrite(bag, {
+    runtime,
+    getState,
+    set,
+    flushEmitImmediate,
+    routeState,
+    syncContextStats,
+    publishRoute,
+  });
 
   const setWebSearchRoute = async (opts) => {
     if (getState().commandBusy) return null;
@@ -272,62 +102,7 @@ export function createSessionRouteApi(bag) {
       return runtime.listWebSearchModels?.(options) || [];
     },
     setWebSearchRoute,
-    listAgents: () => {
-      return runtime.listAgents?.() || [];
-    },
-    listWorkflows: () => {
-      return runtime.listWorkflows?.() || [];
-    },
-    // Workflow pack editing (desktop Workflows page): direct passthroughs —
-    // the runtime owns validation, user-pack persistence, and delete guards.
-    getWorkflowPack: (workflowId) => runtime.getWorkflowPack?.(workflowId) ?? null,
-    saveWorkflowPack: async (payload) => runtime.saveWorkflowPack?.(payload) ?? null,
-    createWorkflow: async (payload) => runtime.createWorkflow?.(payload) ?? null,
-    deleteWorkflow: async (workflowId) => runtime.deleteWorkflow?.(workflowId) ?? null,
-    getAgentDefinition: (agentId) => runtime.getAgentDefinition?.(agentId) ?? null,
-    getAgentAvatarImage: (agentId) => runtime.getAgentAvatarImage?.(agentId) ?? null,
-    getAgentConnectors: (agentId) => runtime.getAgentConnectors?.(agentId) ?? [],
-    listConnectors: () => runtime.listConnectors?.() ?? [],
-    listConnectorTools: (connectorId) => runtime.listConnectorTools?.(connectorId) ?? [],
-    setAgentConnectors: async (agentId, connectors) => runtime.setAgentConnectors?.(agentId, connectors) ?? null,
-    setAgentConnectorEnabled: async (agentId, connectorId, enabled) =>
-      runtime.setAgentConnectorEnabled?.(agentId, connectorId, enabled) ?? [],
-    getProjectConnectors: (projectPath) => runtime.getProjectConnectors?.(projectPath) ?? [],
-    setProjectConnectorEnabled: async (projectPath, connectorId, enabled) =>
-      runtime.setProjectConnectorEnabled?.(projectPath, connectorId, enabled) ?? [],
-    setAgentConnectorToolPermission: async (agentId, connectorId, toolName, permission) =>
-      runtime.setAgentConnectorToolPermission?.(agentId, connectorId, toolName, permission) ?? null,
-    // Per-agent action-kind permissions (ask / allow / block) for the profile.
-    getAgentPermissions: async (agentId) =>
-      (await import('../../../runtime/agent/orchestrator/session/human-gate/store.mjs')).agentPermissions(agentId),
-    setAgentPermission: async (agentId, action, mode) =>
-      (await import('../../../runtime/agent/orchestrator/session/human-gate/store.mjs')).setAgentPermission(
-        agentId,
-        action,
-        mode
-      ),
-    getLeadPersona: () => runtime.getLeadPersona?.() ?? '',
-    saveLeadPersona: async (text) => runtime.saveLeadPersona?.(text) ?? '',
-    getLeadAgentBody: () => runtime.getLeadAgentBody?.() ?? '',
-    saveLeadAgentBody: async (text) => runtime.saveLeadAgentBody?.(text) ?? '',
-    getLeadStatus: () =>
-      runtime.getLeadStatus?.() ?? { created: null, name: '', avatar: null, homeChatted: false, route: null },
-    saveLeadIdentity: async (payload) => runtime.saveLeadIdentity?.(payload) ?? null,
-    setLeadCreated: async (created, description) => runtime.setLeadCreated?.(created, description) ?? null,
-    saveAgentDefinition: async (payload) => runtime.saveAgentDefinition?.(payload) ?? null,
-    deleteAgentDefinition: async (agentId) => runtime.deleteAgentDefinition?.(agentId) ?? null,
-    agentDefinitionPresence: (agentIds) => runtime.agentDefinitionPresence?.(agentIds) ?? null,
-    restoreAgentDefinition: async (agentId) => runtime.restoreAgentDefinition?.(agentId) ?? null,
-    purgeAgentDefinition: async (agentId) => runtime.purgeAgentDefinition?.(agentId) ?? null,
-    archivedAgentIdentities: (agentIds) => runtime.archivedAgentIdentities?.(agentIds) ?? null,
-    // Group-room rows posted by the desktop host into a room's log session.
-    appendRoomRows: async (sessionId, rows) =>
-      (await import('../../../session-runtime/agent-room-delivery.mjs')).appendRoomRows(sessionId, rows),
-    // One group-room supervisor step on the Maintainer route.
-    decideRoomTurn: async (input) =>
-      (await import('../../../runtime/agent/orchestrator/agent-runtime/room-supervisor-completion.mjs')).decideRoomTurn(
-        input
-      ),
+    ...createAgentDefinitionApi(runtime),
     getOutputStyle: () => {
       return runtime.getOutputStyle?.() || runtime.listOutputStyles?.() || null;
     },
@@ -348,13 +123,14 @@ export function createSessionRouteApi(bag) {
     setWorkflow: withCommandLock(async (workflowId, options) => {
       const result = await runtime.setWorkflow?.(workflowId, options);
       // A switch of this conversation leaves a divider (restored from message meta).
-      if (result?.workflowSwitch) bag.pushItem(workflowSwitchItem(bag.nextId(), result.workflowSwitch));
+      publishSessionSwitches(bag, { workflowSwitch: result?.workflowSwitch });
       publishRoute();
       return result;
     }),
     getOrchestrationMode: () => runtime.getOrchestrationMode(),
-    setOrchestrationMode: withCommandLock(async (mode) => {
-      const result = await runtime.setOrchestrationMode(mode);
+    setOrchestrationMode: withCommandLock(async (mode, options) => {
+      const result = await runtime.setOrchestrationMode(mode, options);
+      publishSessionSwitches(bag, { orchestrationModeSwitch: result?.orchestrationModeSwitch });
       publishRoute();
       return result;
     }),

package/src/tui/session/session-api/settings.mjs

@@ -112,6 +112,18 @@ export function createSessionSettingsApi(bag) {
     setAiSessionTitles: withCommandLock(async (enabled) => {
       return await runtime.setAiSessionTitles?.(enabled);
     }),
+    getLeadAppearance: () => {
+      return runtime.getLeadAppearance?.() || { avatar: null };
+    },
+    setLeadAppearance: withCommandLock(async (avatar) => {
+      return await runtime.setLeadAppearance?.(avatar);
+    }),
+    getBotOrder: () => {
+      return runtime.getBotOrder?.() || { order: [] };
+    },
+    setBotOrder: withCommandLock(async (order) => {
+      return await runtime.setBotOrder?.(order);
+    }),
     getToolModuleSettings: () => {
       return (
         runtime.getToolModuleSettings?.() || {
@@ -130,9 +142,10 @@ export function createSessionSettingsApi(bag) {
     setWorktreeSettings: lockedRuntimeCall((patch) => runtime.setWorktreeSettings(patch)),
     setWebSearchEnabled: lockedRuntimeCall((enabled) => runtime.setWebSearchEnabled?.(enabled)),
     setInstructionFiles: lockedRuntimeCall((mode) => runtime.setInstructionFiles?.(mode)),
+    setAutoEffortBase: lockedRuntimeCall((level) => runtime.setAutoEffortBase?.(level)),
     setMemoryToolsEnabled: lockedRuntimeCall((enabled) => runtime.setMemoryToolsEnabled?.(enabled)),
     setBuiltinToolEnabled: lockedRuntimeCall((name, enabled) => runtime.setBuiltinToolEnabled?.(name, enabled)),
-    installBuiltinFeature: lockedRuntimeCall((name) => runtime.installBuiltinFeature?.(name)),
+    installBuiltinFeature: lockedRuntimeCall((name, options) => runtime.installBuiltinFeature?.(name, options)),
     installLocalProviderModel: lockedRuntimeCall((modelId) => runtime.installLocalProviderModel?.(modelId)),
     // Background installs return promptly; cancellation must remain usable
     // even while a legacy blocking install owns commandBusy.

package/src/tui/session/session-flow/drain.mjs

@@ -63,8 +63,13 @@ function renderBatchItems(batch, pushUserOrSyntheticItem) {
       .trim()
       .toLowerCase();
     const device = typeof entry.transcriptMeta?.device === 'string' ? entry.transcriptMeta.device : '';
-    const attribution = { ...(sender ? { sender } : {}), ...(device ? { device } : {}) };
-    let itemExtras = sender || device ? attribution : null;
+    const fromAgent = typeof entry.transcriptMeta?.fromAgent === 'string' ? entry.transcriptMeta.fromAgent : '';
+    const attribution = {
+      ...(sender ? { sender } : {}),
+      ...(device ? { device } : {}),
+      ...(fromAgent ? { fromAgent } : {}),
+    };
+    let itemExtras = sender || device || fromAgent ? attribution : null;
     if (Array.isArray(entry.images) && entry.images.length) {
       itemExtras = { images: entry.images, ...attribution };
     }
@@ -84,6 +89,23 @@ function batchPromptSource(batch) {
   return undefined;
 }
 
+/** The batch's transcript metadata; a batch of completion wakes also records
+ *  the execution ids it delivers (`consumedExecutionIds`, from each entry's
+ *  execution or resume keys; null for one with neither), the structured
+ *  provenance a task session's report follows (agent-task-sessions.mjs). */
+function completionWakeTranscriptMeta(batch) {
+  const meta = batch[0]?.transcriptMeta || null;
+  if (batchPromptSource(batch) !== 'task-notification') return meta;
+  const consumed = batch.flatMap((entry) => {
+    if (entry?.execution?.id) return [String(entry.execution.id)];
+    const keys = (Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : []).map(String);
+    return keys.length
+      ? keys.map((key) => (key.startsWith('execution:') ? key.slice('execution:'.length) : null))
+      : [null];
+  });
+  return { ...(meta || {}), consumedExecutionIds: consumed };
+}
+
 export function turnOptionsForBatch(batch, steering) {
   const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
   // A completion resume is owned by the completion that woke it. Esc
@@ -106,13 +128,16 @@ export function turnOptionsForBatch(batch, steering) {
     pastedTexts: mergePastedTexts(batch),
     submittedAt: earliestSubmittedAt(batch),
     onCommitted: () => steering.commitSteeringQueueEntries(batch),
+    // Cancelling typed input consumes its queue copy with or without draft
+    // restoration, without signalling successful delivery to onCommitted.
+    onAborted: () => steering.releaseSteeringQueueEntries(batch),
     submittedIds: [...new Set(batch.map((e) => e.id))],
     restorable: nonEditable.length === 0,
     requeueOnAbort: nonEditable.filter((entry) => !discardOnAbort.includes(entry)),
     discardExecutionPendingResumeKeys: discardOnAbort.flatMap((entry) =>
       Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : []
     ),
-    transcriptMeta: batch[0]?.transcriptMeta || null,
+    transcriptMeta: completionWakeTranscriptMeta(batch),
     // Only a routine turn names its selection text (never its payload).
     ...(batch[0]?.mode === 'routine' && typeof batch[0].skillSelection === 'string'
       ? { skillSelection: batch[0].skillSelection }

package/src/tui/session/session-flow/failed-turn-rewind.mjs

@@ -6,8 +6,10 @@
 const TURN_CHROME_KINDS = new Set(['user', 'turndone', 'notice']);
 
 // An in-place model switch made after the stop (the quota "switch model"
-// path) is not the failed turn's output and outlives its rewind.
-const isModelSwitchDivider = (item) => item?.kind === 'statusdone' && item.status === 'model-switched';
+// path), or a model, workflow or orchestration mode switch applied at the
+// failed turn's start, is not the turn's output and outlives its rewind.
+const SWITCH_DIVIDERS = new Set(['model-switched', 'workflow-switched', 'orchestration-mode-switched']);
+const isModelSwitchDivider = (item) => item?.kind === 'statusdone' && SWITCH_DIVIDERS.has(item.status);
 
 /** The items with the trailing failed, output-less turn removed (a later
  *  model switch divider kept), or null when nothing qualifies. */

package/src/tui/session/session-flow/queue/take-entries.mjs

@@ -13,6 +13,12 @@ import {
 import { hydratePastedAttachments, hydrateRestorableFileParts } from '../../../../runtime/attachments/store.mjs';
 import { dropTuiSteeringPersist } from '../../tui-steering-persist.mjs';
 
+/** Who an entry's words are attributed to (its `sender`, sending bot and chain hop). */
+const attributionOf = (entry) =>
+  `${String(entry?.transcriptMeta?.sender || '').toLowerCase()}|${entry?.transcriptMeta?.fromAgent || ''}|${
+    entry?.transcriptMeta?.hop || 0
+  }`;
+
 export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQueuedEntries, leadSessionId }) {
   function dequeueQueueBatch(maxPriority = 'later', options = {}) {
     if (pending.length === 0) return [];
@@ -40,6 +46,8 @@ export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQ
         queuePriorityValue(entry.priority) === bestPriority
       ) {
         if (batch.length > 0 && entry.retryTurnId) break;
+        // One turn records one sender: a bot's message never merges with the user's.
+        if (batch.length > 0 && attributionOf(entry) !== attributionOf(batch[0])) break;
         batch.push(entry);
         pending.splice(i, 1);
         if (entry.mode === 'task-notification' && entry.key) pendingNotificationKeys.delete(entry.key);

package/src/tui/session/session-flow/steering.mjs

@@ -127,12 +127,16 @@ export function createSteeringOps(bag, { queue, submissions }) {
     return isQueuedEntryEditable(entry) && !isSlashQueuedEntry(entry);
   }
 
-  function commitSteeringQueueEntries(entries) {
-    callCommitCallbacks(entries);
+  function releaseSteeringQueueEntries(entries) {
     const mirrored = (Array.isArray(entries) ? entries : []).filter(
       (entry) => shouldMirrorSteeringEntry(entry) && entry.steeringPersistId
     );
-    if (mirrored.length > 0) dropTuiSteeringPersist(leadSessionId(), mirrored);
+    if (mirrored.length > 0) return dropTuiSteeringPersist(leadSessionId(), mirrored);
+  }
+
+  function commitSteeringQueueEntries(entries) {
+    callCommitCallbacks(entries);
+    releaseSteeringQueueEntries(entries);
   }
 
   function canDeliverSteeringEntry(entry) {
@@ -291,6 +295,7 @@ export function createSteeringOps(bag, { queue, submissions }) {
   return {
     leadSessionId,
     shouldMirrorSteeringEntry,
+    releaseSteeringQueueEntries,
     commitSteeringQueueEntries,
     settleSteeredSubmissions,
     hasPendingSteering,