mixdog 1.3.1 → 1.3.3

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

@@ -0,0 +1,169 @@
+// Mid-conversation workflow and orchestration-mode switches of a coding
+// session (see createToolPolicyRefresh for the cache contract they share).
+import { sessionHasConversationMessages } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { toSessionWorkflowMeta } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
+import { AGENT_MODE, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { applyOrchestrationModeSwitch } from './mode-switch.mjs';
+import { createPendingSwitchApplier } from './pending-switches.mjs';
+import { configForSession, configForWorkflow, currentMode, leadPartsFor } from './surface-helpers.mjs';
+import { createWorkflowOverlay } from './workflow-overlay.mjs';
+
+// The session a mid-conversation switch applies to: a coding session with a
+// conversation (null: none, the caller's empty-session path applies);
+// anything else cannot switch.
+function switchableConversation(session, what) {
+  if (!session?.id) return false;
+  if (
+    !sessionHasConversationMessages(session) &&
+    !sessionHasConversationMessages({ messages: session.liveTurnMessages })
+  ) {
+    return false;
+  }
+  if (isAgentOwner(session) || sessionModeOf(session) === AGENT_MODE) {
+    throw new Error(`Only a coding session has a ${what}.`);
+  }
+  if (!session.promptIdentity) throw new Error(`This session is too old to switch its ${what}; start a new task.`);
+  return true;
+}
+
+// A choice made while a turn runs waits for the next turn: the latest one
+// wins and a choice of what the session already runs cancels it.
+function stagePendingSwitch(session, field, value, current) {
+  if (value === current) delete session[field];
+  else session[field] = value;
+  session.updatedAt = Date.now();
+}
+
+export function createSessionSwitches({
+  getSession,
+  getConfig,
+  getDataDir,
+  modelStandaloneTools,
+  activeWorkflowContext,
+  persistSession,
+  liveDeniedTools,
+  turnInFlight,
+}) {
+  const { applyWorkflowSwitch } = createWorkflowOverlay({
+    liveDeniedTools,
+    modelStandaloneTools,
+  });
+
+  // The workflow `workflowId` names with orchestration mode `mode`, and its
+  // Lead prompt parts, read before anything changes. The pack loader falls
+  // back to the default pack for a missing id, so a different id is a gone one.
+  function resolveWorkflow(session, workflowId, mode) {
+    const target = activeWorkflowContext(configForSession(getConfig(), workflowId, mode), getDataDir());
+    if (target.summary?.id !== workflowId) throw new Error(`workflow "${workflowId}" not found`);
+    return { target, parts: leadPartsFor(session, target.leadPromptParts) };
+  }
+
+  // The shared flow of a mid-conversation switch: null without a conversation;
+  // while a turn runs the choice is staged, else applied; saved either way.
+  async function switchConversation(what, { pendingField, value, current, deferredResult, apply }) {
+    const session = getSession?.();
+    if (!switchableConversation(session, what)) return null;
+    let result;
+    if (turnInFlight(session)) {
+      stagePendingSwitch(session, pendingField, value, current(session));
+      result = deferredResult(session);
+    } else {
+      result = apply(session);
+    }
+    await persistSession(session);
+    return result;
+  }
+
+  /**
+   * Switch the current coding session's workflow mid-conversation (the
+   * composer's workflow selector). The request prefix — BP1, BP2, BP3 and the
+   * tool schemas — stays byte-identical, so the provider cache survives: the
+   * session's workflow metadata changes now, and the next turn carries a
+   * self-contained reminder with the new workflow's rules, orchestration,
+   * agents and tool changes (manager/workflow-switch-notice.mjs). Tools the new
+   * workflow denies keep their schema and are refused at call time; tools it
+   * allows that the schema lacks stay unavailable until a new session. The
+   * prompt takes the new workflow at the next point where the cache is cold
+   * anyway (foldPromptIfCold). Never refused while a turn runs: the choice is
+   * staged (`pendingWorkflowId`, the last one wins, a pick of the current
+   * workflow cancels it) and applied when the next turn starts
+   * (applyPendingSessionSwitches). Either way the session is saved before
+   * this returns, so an acknowledged choice outlives a daemon restart. The
+   * configured workflow (the default for new sessions) is the caller's and
+   * stays as it is; the session keeps its own orchestration mode.
+   *
+   * Running work is untouched: agents and workers the session started under
+   * the old workflow are separate sessions with their own prompts and tools,
+   * so they keep running as they are (unlike a working-folder change, running
+   * agents never refuse this); only delegation made from the next turn on
+   * uses the new surface.
+   *
+   * Returns null when the session has no conversation (the caller applies the
+   * configured workflow to an empty session as before), else
+   * `{ appliedToCurrentSession: true, workflow, workflowSwitch }` where
+   * `workflowSwitch` is the transcript boundary (null when unchanged or
+   * deferred; a deferred switch answers `deferred: true` and the workflow
+   * the session will run).
+   */
+  async function switchSessionWorkflow(workflowId) {
+    return switchConversation('workflow', {
+      pendingField: 'pendingWorkflowId',
+      value: workflowId,
+      current: (session) => session.workflow?.id,
+      deferredResult: (session) => {
+        const shown = session.pendingWorkflowId
+          ? toSessionWorkflowMeta(
+              activeWorkflowContext(configForWorkflow(getConfig(), session.pendingWorkflowId), getDataDir()).summary
+            )
+          : session.workflow;
+        return { appliedToCurrentSession: true, deferred: true, workflow: shown, workflowSwitch: null };
+      },
+      apply: (session) => {
+        const resolved = resolveWorkflow(session, workflowId, currentMode(session));
+        delete session.pendingWorkflowId;
+        return applyWorkflowSwitch(session, resolved);
+      },
+    });
+  }
+
+  /**
+   * Switch the current coding session's orchestration (delegation) mode
+   * mid-conversation, on the workflow switch's pattern: the request prefix
+   * stays byte-identical, the session's mode changes now, and the next turn
+   * carries a reminder with the new mode's rules (the block BP3 carries;
+   * manager/orchestration-mode-switch-notice.mjs). The mode never changes
+   * which tools may run — Solo still lets the Lead load `agent` when the user
+   * asks — only how eagerly delegation is offered: the eager/deferred split
+   * stays the prompt's (tool-catalog.mjs), so a mode that delegates while the
+   * schema holds `agent` only as a deferred tool tells the model to load it.
+   * Back on the prompt's mode the overlay is dropped; the prompt takes the
+   * new mode at the next cold point (foldPromptIfCold). While a turn runs the
+   * choice waits for the next turn (stagePendingSwitch). Either way the
+   * session is saved before this returns. The configured mode (the default
+   * for new sessions) is the caller's and stays as it is.
+   * Returns null without a conversation (the caller's empty-session path),
+   * else `{ appliedToCurrentSession: true, mode, orchestrationModeSwitch }`.
+   */
+  async function switchSessionOrchestrationMode(mode) {
+    return switchConversation('orchestration mode', {
+      pendingField: 'pendingOrchestrationMode',
+      value: mode,
+      current: currentMode,
+      deferredResult: (session) => ({
+        appliedToCurrentSession: true,
+        deferred: true,
+        mode: session.pendingOrchestrationMode ?? currentMode(session),
+        orchestrationModeSwitch: null,
+      }),
+      apply: (session) => {
+        delete session.pendingOrchestrationMode;
+        return applyOrchestrationModeSwitch(session, mode);
+      },
+    });
+  }
+
+  const applyPendingSessionSwitches = createPendingSwitchApplier({ getSession, resolveWorkflow, applyWorkflowSwitch });
+
+  return { switchSessionWorkflow, switchSessionOrchestrationMode, applyPendingSessionSwitches };
+}

package/src/session-runtime/tool-policy/surface-helpers.mjs

@@ -0,0 +1,114 @@
+// Pure helpers of the tool-policy refresh: reading a session's tool surface,
+// rewriting its system blocks (BP1 heading, BP3 core), and the configs a
+// session's workflow and orchestration mode give.
+import { AGENT_MODE, resolveSessionMode, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { MIXY_AGENT_ID } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { refreshSessionBp3Environment } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { promptOrchestrationModeOf } from '../../runtime/agent/orchestrator/session/manager/orchestration-mode-switch-notice.mjs';
+import { sessionOrchestrationMode } from '../../runtime/shared/orchestration.mjs';
+
+export const toolName = (tool) => String(tool?.name || '');
+
+// Every tool definition the session's schema or deferred catalogs hold.
+export function schemaTools(session) {
+  return [
+    ...(Array.isArray(session.tools) ? session.tools : []),
+    ...(Array.isArray(session.deferredToolCatalog) ? session.deferredToolCatalog : []),
+    ...(Array.isArray(session.deferredLateToolCatalog) ? session.deferredLateToolCatalog : []),
+  ];
+}
+
+export function toolNames(list) {
+  return (Array.isArray(list) ? list : [])
+    .map((item) => (typeof item === 'string' ? item : item?.name))
+    .filter(Boolean);
+}
+
+function replaceMessageContent(messages, target, content) {
+  const index = messages.indexOf(target);
+  if (index < 0) return false;
+  messages[index] = { ...target, content };
+  return true;
+}
+
+export function rewriteSystemHeading(session, heading, nextContent) {
+  if (!nextContent) return;
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  const target = messages.find(
+    (message) =>
+      message?.role === 'system' && typeof message.content === 'string' && message.content.startsWith(heading)
+  );
+  if (target) replaceMessageContent(messages, target, nextContent);
+}
+
+function bp3Message(session) {
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  return (
+    messages.find((message) => message?.role === 'system' && message.cacheTier === 'tier3') ||
+    messages.find(
+      (message) =>
+        message?.role === 'system' &&
+        typeof message.content === 'string' &&
+        message.content.startsWith('# Active Workflow:')
+    )
+  );
+}
+
+// The BP3 core the session's prompt carries now (split layout: the whole
+// tier3 block; combined: the stored core beside the environment).
+export function presentedBp3Core(session) {
+  return session.bp3EnvSplit === true ? bp3Message(session)?.content : session.bp3CoreContext;
+}
+
+export function rewriteBp3Core(session, nextCore) {
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  const bp3 = bp3Message(session);
+  if (!bp3 || typeof bp3.content !== 'string') return;
+  if (session.bp3EnvSplit === true) {
+    // Split layout: the environment lives in its own cacheTier:'env' system
+    // block — the tier3 block carries the core only.
+    replaceMessageContent(messages, bp3, nextCore || '');
+    session.bp3CoreContext = nextCore || '';
+    return;
+  }
+  const env = session.bp3EnvironmentContext || '';
+  replaceMessageContent(messages, bp3, [nextCore, env].filter((part) => String(part || '').trim()).join('\n\n---\n\n'));
+  session.bp3CoreContext = nextCore || '';
+}
+
+// A Lead's workflow slices (orchestration, agent and contact catalogs) for its
+// mode, Mixy's with the contacts.
+export function leadPartsFor(session, leadPromptParts) {
+  return leadPromptParts({
+    agentMode: sessionModeOf(session) === AGENT_MODE,
+    mixy: resolveSessionMode({ session }).agentId === MIXY_AGENT_ID,
+  });
+}
+
+// A conversation keeps its `# Session` block: the legacy combined layout
+// rebuilds the tier3 block from the new core (rooted where it was).
+export function rewriteConversationBp3Core(session, nextCore) {
+  if (session.bp3EnvSplit !== true && typeof session.bp3CoreContext === 'string') {
+    const previous = session.bp3CoreContext;
+    session.bp3CoreContext = nextCore;
+    if (refreshSessionBp3Environment(session, session.cwd)) return;
+    session.bp3CoreContext = previous;
+  }
+  rewriteBp3Core(session, nextCore);
+}
+
+// `config` with `workflowId` as the active workflow (itself when absent).
+export function configForWorkflow(config, workflowId) {
+  return workflowId ? { ...config, workflow: { ...(config?.workflow || {}), active: workflowId } } : config;
+}
+
+// A conversation's config: its workflow and its own orchestration mode
+// (`mode`), never the configured default for new sessions.
+export function configForSession(config, workflowId, mode) {
+  return { ...configForWorkflow(config, workflowId), orchestrationMode: mode };
+}
+
+// The session's orchestration mode now (a legacy record derives it).
+export const currentMode = (session) => sessionOrchestrationMode(session);
+// The mode its prompt was built with.
+export const promptMode = (session) => promptOrchestrationModeOf(session) ?? currentMode(session);

package/src/session-runtime/tool-policy/workflow-overlay.mjs

@@ -0,0 +1,145 @@
+// Applying a mid-conversation workflow switch: the overlay it lays over the
+// session's prompt, and the tool changes it makes reachable without touching
+// the prefix.
+import { toSessionWorkflowMeta } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import {
+  promptWorkflowOf,
+  stageWorkflowSwitchNotice,
+  workflowOverlayContent,
+} from '../../runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs';
+import { mergePendingDeferredToolDelta } from '../../runtime/agent/orchestrator/runtime-core/deferred-tool-delta.mjs';
+import { recordTranscriptBoundary } from '../model-route/set-route.mjs';
+import { promptMode, schemaTools, toolName } from './surface-helpers.mjs';
+
+export function createWorkflowOverlay({ liveDeniedTools, modelStandaloneTools }) {
+  // The overlay of a switch to `target` while the prompt carries `prompt`
+  // (manager/workflow-switch-notice.mjs): what the reminder tells the Lead and
+  // which calls are refused. Nothing in the request prefix moves.
+  function workflowOverlay(session, { target, parts }, { prompt, promptOrchestrationMode }) {
+    const denied = new Set(liveDeniedTools(session, target.summary).map((name) => name.toLowerCase()));
+    const disallowed = new Set((session.disallowedTools || []).map((name) => String(name).toLowerCase()));
+    const deniedTools = [
+      ...new Set(
+        schemaTools(session)
+          .map(toolName)
+          .filter((name) => name && denied.has(name.toLowerCase()) && !disallowed.has(name.toLowerCase()))
+      ),
+    ];
+    // Tools the new workflow allows that the session's policy denied (`agent`
+    // after a switch to a workflow with agents): reachable by deferred loading.
+    // `modelStandaloneTools` follows the session's workflow here (the caller
+    // drops the old overlay first), so their definitions are current.
+    // An earlier switch may have opened one already (workflowOpenedTools).
+    const reopened = [
+      ...new Set([...(session.disallowedTools || []), ...(session.workflowOpenedTools || [])].map(String)),
+    ].filter((name) => !denied.has(name.toLowerCase()));
+    const known = new Set(schemaTools(session).map(toolName));
+    const fresh = modelStandaloneTools().filter(
+      (tool) => reopened.includes(toolName(tool)) && !known.has(toolName(tool))
+    );
+    for (const tool of fresh) known.add(toolName(tool));
+    const loadableTools = reopened.filter((name) => known.has(name));
+    const unavailableTools = reopened.filter((name) => !known.has(name));
+    const workflow = { id: target.summary.id, name: target.summary.name || target.summary.id };
+    const instructions = [
+      target.packContext,
+      parts.orchestrationContext ||
+        `# Delegation\n\n${workflow.name} has no agents to delegate to: do the work yourself.`,
+      parts.agentCatalogContext,
+    ]
+      .map((part) => String(part || '').trim())
+      .filter(Boolean)
+      .join('\n\n');
+    const overlay = {
+      prompt,
+      promptOrchestrationMode,
+      workflow,
+      orchestrationMode: target.orchestrationMode,
+      deniedTools,
+      loadableTools,
+      unavailableTools,
+      content: workflowOverlayContent({
+        promptName: prompt?.name || prompt?.id || 'the previous workflow',
+        workflow,
+        instructions,
+        deniedTools,
+        loadableTools,
+        unavailableTools,
+      }),
+    };
+    return { overlay, fresh };
+  }
+
+  // Make a switch's loadable tools reachable without touching the prefix: their
+  // definitions join the deferred catalog, the policy stops denying them, and
+  // the next turn's deferred_tools_delta names them. Switching back refuses
+  // them again (the overlay's deniedTools, or the policy's deny list below).
+  function openLoadableTools(session, { loadableTools, fresh }) {
+    if (!loadableTools.length) return;
+    const opened = session.workflowOpenedTools || [];
+    session.workflowOpenedTools = [...new Set([...opened, ...loadableTools])];
+    if (fresh.length) session.deferredToolCatalog = [...(session.deferredToolCatalog || []), ...fresh];
+    session.disallowedTools = (session.disallowedTools || []).filter((name) => !loadableTools.includes(String(name)));
+    const byName = new Map(schemaTools(session).map((tool) => [toolName(tool), tool]));
+    // Announced on every switch that opens them: a pending removal (a switch
+    // back in between) cancels against it rather than lingering.
+    mergePendingDeferredToolDelta(session, {
+      added: loadableTools.map((name) => ({ name, description: byName.get(name)?.description || '' })),
+    });
+  }
+
+  // Back on the workflow the prompt carries: tools an earlier switch opened
+  // that it denies are denied again (call-time refusal; the schema stays).
+  function closeReopenedTools(session, target) {
+    const denied = new Set(liveDeniedTools(session, target.summary));
+    const disallowed = new Set((session.disallowedTools || []).map(String));
+    const known = new Set(schemaTools(session).map(toolName));
+    const closed = [...denied].filter((name) => known.has(name) && !disallowed.has(name));
+    if (!closed.length) return;
+    session.disallowedTools = [...disallowed, ...closed];
+    mergePendingDeferredToolDelta(session, { removed: closed });
+  }
+
+  function applyWorkflowSwitch(session, resolved) {
+    const { target } = resolved;
+    const before = session.workflow;
+    const from = before?.id ? before : null;
+    const prompt = promptWorkflowOf(session);
+    const promptOrchestrationMode = promptMode(session);
+    session.workflow = toSessionWorkflowMeta(target.summary);
+    session.orchestrationMode = target.orchestrationMode;
+    delete session.workflowOverlay;
+    if (session.workflow.id === prompt?.id) closeReopenedTools(session, target);
+    else {
+      const { overlay, fresh } = workflowOverlay(session, resolved, { prompt, promptOrchestrationMode });
+      openLoadableTools(session, { loadableTools: overlay.loadableTools, fresh });
+      session.workflowOverlay = overlay;
+    }
+    session.updatedAt = Date.now();
+    stageWorkflowSwitchNotice(session, from, session.workflow);
+    let workflowSwitch = null;
+    if (from?.id !== session.workflow.id) {
+      workflowSwitch = {
+        fromId: from?.id || '',
+        from: from?.name || from?.id || '',
+        toId: session.workflow.id,
+        to: session.workflow.name,
+        at: Date.now(),
+      };
+      // Two switches can land in the same millisecond (A→B→A): the same
+      // switch is a repeat only when its direction matches too.
+      recordTranscriptBoundary(
+        session,
+        'workflowSwitches',
+        workflowSwitch,
+        (entry) =>
+          entry?.at === workflowSwitch.at &&
+          entry?.fromId === workflowSwitch.fromId &&
+          entry?.toId === workflowSwitch.toId
+      );
+    }
+    return { appliedToCurrentSession: true, workflow: session.workflow, workflowSwitch };
+  }
+
+  return { applyWorkflowSwitch };
+}