mixdog 1.2.6 → 1.3.0

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

@@ -48,11 +48,21 @@ export function createWorkflowPacksApi(deps) {
     }));
   }
 
-  async function setWorkflow(workflowId) {
+  // `{ scope: 'session' }` (the composer's selector in a session): a session
+  // with a conversation switches alone from its next turn
+  // (switchSessionWorkflow) and the configured workflow — the default for new
+  // sessions — stays as it is. Without a conversation, and without the
+  // scope, the choice becomes the configured workflow and an empty session
+  // picks it up in place, as before.
+  async function setWorkflow(workflowId, options = {}) {
     const requested = normalizeWorkflowId(workflowId, DEFAULT_WORKFLOW_ID);
     const id = requested === 'solo' ? DEFAULT_WORKFLOW_ID : requested;
     const pack = loadWorkflowPack(resolveDataDir(deps), id);
     if (!pack || pack.id !== id) throw new Error(`workflow "${workflowId}" not found`);
+    if (options?.scope === 'session') {
+      const switched = await deps.switchSessionWorkflow?.(id);
+      if (switched) return { ...switched.workflow, ...switched };
+    }
     saveActiveWorkflow(id);
     const applied = await deps.refreshEmptySessionToolPolicy?.();
     deps.invalidatePreSessionToolSurface?.();

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

@@ -1,5 +1,6 @@
 import { createOnboardingApi } from './workflow-agents-api/onboarding.mjs';
 import { createAgentEditorApi } from './workflow-agents-api/agent-editor.mjs';
+import { createAgentConnectorsApi } from './workflow-agents-api/agent-connectors.mjs';
 import { createAgentRouteApi } from './workflow-agents-api/agent-route.mjs';
 import { createWorkflowPacksApi } from './workflow-agents-api/workflow-packs.mjs';
 import { createStyleAndModeApi } from './workflow-agents-api/style-and-mode.mjs';
@@ -11,9 +12,11 @@ import { createStyleAndModeApi } from './workflow-agents-api/style-and-mode.mjs'
 // getOnboardingStatus from the composed runtime API through `this`.
 export function createWorkflowAgentsApi(deps) {
   const routeApi = createAgentRouteApi(deps);
+  const editorApi = createAgentEditorApi({ ...deps, setAgentRoute: routeApi.setAgentRoute });
   return {
     ...createOnboardingApi(deps),
-    ...createAgentEditorApi({ ...deps, setAgentRoute: routeApi.setAgentRoute }),
+    ...editorApi,
+    ...createAgentConnectorsApi(deps, editorApi),
     ...routeApi,
     ...createWorkflowPacksApi(deps),
     ...createStyleAndModeApi(deps),

package/src/standalone/daemon-agent-control.mjs

@@ -8,8 +8,6 @@
 // this control exists — the host takes `execute` as a constructor option), and
 // `cwd`. Output: { canonicalAgentTool, execute }.
 
-import { deliverAutomationCompletion } from '../session-runtime/automation-agents.mjs';
-
 export function createCanonicalAgentControl({ getSessionService, getSessionRuntimeHost, cwd }) {
   let canonicalAgentToolPromise = null;
 
@@ -34,12 +32,7 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
           isKeychainPrewarmReady: () => true,
           sessionSurface: sessionService.agentSurface,
           notifySessionCompletion(ownerSessionId, text, meta = {}) {
-            // A schedule/webhook run owns no session runtime; its own
-            // agent-result waiter takes the completions it is owed.
-            return (
-              getSessionRuntimeHost()?.notifySessionCompletion?.(ownerSessionId, text, meta) === true ||
-              deliverAutomationCompletion(ownerSessionId, text, meta)
-            );
+            return getSessionRuntimeHost()?.notifySessionCompletion?.(ownerSessionId, text, meta) === true;
           },
         });
       })

package/src/standalone/daemon-session-control.mjs

@@ -1,20 +1,26 @@
 import { SESSION_ID_PATTERN } from '../runtime/agent/orchestrator/runtime-core/session-id.mjs';
 import { sessionListOutput, sessionReadOutput, SESSION_TOOL_OUTPUT_BYTES } from './session-tool-output.mjs';
+import { createAgentTaskSessions } from '../session-runtime/agent-task-sessions.mjs';
 
 const TARGET_ACTIONS = new Set(['status', 'read', 'send', 'cancel', 'delete']);
 const MUTATING_ACTIONS = new Set(['send', 'cancel', 'delete']);
 
 /** Model-facing session operations over the same service used by desktop and TUI. */
-export function createSessionControl({ getSessionService }) {
+export function createSessionControl({
+  getSessionService,
+  agentTasks = createAgentTaskSessions({ getSessionService }),
+}) {
   return async function executeSessionControl(args = {}, context = {}) {
     const action = args.action;
-    if (action !== 'list' && !TARGET_ACTIONS.has(action)) {
+    if (action !== 'list' && action !== 'create' && !TARGET_ACTIONS.has(action)) {
       throw new Error(`session: unsupported remote action "${action}"`);
     }
     const caller = context.callerSessionId;
     if (typeof caller !== 'string' || !SESSION_ID_PATTERN.test(caller)) {
       throw new Error('session: caller session is required');
     }
+    // `callerAgentId`: set only for an attended agent conversation (workspace-tools.mjs).
+    if (action === 'create') return agentTasks.create(args, context);
     const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
     if (TARGET_ACTIONS.has(action) && (typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId))) {
       throw new Error(`session: session_id is required for action=${action}`);
@@ -45,6 +51,9 @@ export function createSessionControl({ getSessionService }) {
       if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
         throw new Error('session: prompt is required for action=send');
       }
+      // The agent's follow-up in a task session it created reports back too.
+      const origin = await agentTasks.originFor(sessionId, context.callerAgentId);
+      if (origin) return { sessionId, accepted: await agentTasks.send(sessionId, args.prompt, origin) };
       const result = await service.submitSession({
         sessionId,
         prompt: args.prompt,

package/src/standalone/daemon.mjs

@@ -77,6 +77,8 @@ import { createStoredSessionViews } from './daemon-stored-session-views.mjs';
 import * as quotaResumeStore from '../runtime/shared/quota-resume-store.mjs';
 import { registerWorktreeCacheCleanups } from '../runtime/shared/worktrees/cache-cleanups.mjs';
 import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
+import { recoverScheduleResults, setAgentHomeLiveSurface } from '../session-runtime/agent-home-delivery.mjs';
+import { recoverRoutineDeliveries } from '../session-runtime/owned-automation-run.mjs';
 import { getStandaloneMemoryRuntime } from '../session-runtime/services/memory-runtime-proxy.mjs';
 import { registerTranscriptPurgeHook } from '../session-runtime/session-transcript-purge.mjs';
 import { createBootPhaseProfiler } from './boot-phase-profiler.mjs';
@@ -95,7 +97,6 @@ import { createDesktopRuntime } from './daemon-desktop-runtime.mjs';
 import { createCanonicalAgentControl } from './daemon-agent-control.mjs';
 import { createSessionControl } from './daemon-session-control.mjs';
 import { flushAllIndexWrites } from '../session-runtime/services/agent-tool/index-write-queue.mjs';
-import { registerAutomationAgentTool } from '../session-runtime/automation-agents.mjs';
 import {
   compareRuntimeVersions,
   SESSION_CAPABILITY_FINGERPRINT,
@@ -925,9 +926,6 @@ async function main() {
     cwd: CWD,
   });
   canonicalAgentControl = agentControl;
-  // Schedules and webhooks run headless here; their sessions reach the same
-  // canonical agent control through the automation tool scope.
-  registerAutomationAgentTool(agentControl.execute);
   const requestedRuntimeMode = String(process.env.MIXDOG_SESSION_RUNTIME_MODE || '')
     .trim()
     .toLowerCase();
@@ -984,6 +982,22 @@ async function main() {
     },
     log,
   });
+  // Schedule results reach an open home thread at once (and wait out its turn).
+  setAgentHomeLiveSurface({
+    busy: (sessionId) => sessionService.liveSessionBusy(sessionId),
+    notice: (sessionId, notice) => sessionService.pushLiveSessionNotice(sessionId, notice),
+    // A task session's result (session create): the agent relays it in one turn.
+    wake: (sessionId, prompt) =>
+      sessionService.submitSession({ sessionId, prompt, options: { mode: 'prompt', kickoff: true } }),
+    // A routine fire: one queued turn in its bot's thread (routine-home-turn.mjs).
+    submit: async (sessionId, prompt, options) =>
+      (await sessionService.submitSession({ sessionId, prompt, options }))?.accepted === true,
+    abort: (sessionId) => sessionService.abortSession({ sessionId }),
+  });
+  // Results queued before a restart are posted now; results a finished run
+  // could not queue (kept on its routine's record) are queued again.
+  recoverScheduleResults().catch((error) => log(`routine results recovery failed: ${error?.message || error}`));
+  recoverRoutineDeliveries().catch((error) => log(`routine delivery recovery failed: ${error?.message || error}`));
   sessionTransport = createSessionTransport({
     // ctx carries the CLIENT token: the session service refcounts views across
     // processes with it, so a terminal exiting cannot destroy the session a

package/src/standalone/session-protocol.mjs

@@ -9,7 +9,18 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'inspectProjectBranch',
   'isSessionTerminal',
   'contextStatus',
+  'agentDefinitionPresence',
+  'archivedAgentIdentities',
   'getAgentDefinition',
+  'getAgentAvatarImage',
+  'getAgentConnectors',
+  'getProjectConnectors',
+  'getAgentPermissions',
+  'listConnectors',
+  'listConnectorTools',
+  'getLeadPersona',
+  'getLeadAgentBody',
+  'getLeadStatus',
   'getAutoClear',
   'getChannelSettings',
   'getChannelSetup',
@@ -91,6 +102,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'addPlugin',
   'addSkill',
   'agentControl',
+  'appendRoomRows',
   'askSide',
   'authenticateProvider',
   'beginOAuthProviderLogin',
@@ -111,6 +123,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'consumeCodexRateLimitResetCredit',
   'createWorkflow',
   'deleteAgentDefinition',
+  'restoreAgentDefinition',
+  'purgeAgentDefinition',
   'deleteHookRule',
   'deleteMediaAsset',
   'deleteMediaAssets',
@@ -142,7 +156,9 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'reloadSkills',
   'rememberPromptHistory',
   'removeMcpServer',
+  'removeSkill',
   'continueSessionInModel',
+  'decideRoomTurn',
   'scheduleQuotaResume',
   'cancelQuotaResume',
   'retryFailedTurn',
@@ -164,7 +180,18 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'runDoctor',
   'runScheduleNow',
   'runUpdateNow',
+  'runWebhookNow',
+  'retryRoutineDelivery',
   'saveAgentDefinition',
+  'setAgentConnectors',
+  'setAgentConnectorEnabled',
+  'setAgentConnectorToolPermission',
+  'setProjectConnectorEnabled',
+  'setAgentPermission',
+  'saveLeadPersona',
+  'saveLeadAgentBody',
+  'setLeadCreated',
+  'saveLeadIdentity',
   'saveMcpServer',
   'saveOpenAIUsageSessionKey',
   'saveProviderApiKey',

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -11,6 +11,9 @@ import {
 } from '../../../runtime/attachments/store.mjs';
 import { providerNativePdf } from '../../../runtime/agent/orchestrator/providers/registry.mjs';
 import { cancelBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
+import { isAgentModeSession } from '../../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { recognisedAgentRoomSlash } from '../../../tui/app/slash-commands.mjs';
+import { promptContentText } from '../../../tui/session/queue-helpers.mjs';
 
 /** Whether an abort on this session is an Agent cancelling its own turn: the
  *  catalog knows it, the runtime declares agent-only visibility, or it is a
@@ -76,6 +79,12 @@ export function createSessionTurnCalls(ctx) {
         },
       };
     }
+    // A bot's conversation room runs only its own /compact and /clear (the
+    // composer's rule): every other leading `/` is message text for the model.
+    if (isAgentModeSession(entry.runtime.session ?? { id })) {
+      const text = typeof intake.prompt === 'string' ? intake.prompt : promptContentText(intake.prompt);
+      if (!recognisedAgentRoomSlash(text)) submissionOptions = { ...submissionOptions, skipSlashCommands: true };
+    }
     const accepted = await Promise.resolve(target.call(entry.runtime, intake.prompt, submissionOptions));
     if (accepted === true) {
       entry.reservedOnly = false;

package/src/standalone/session-service.mjs

@@ -237,6 +237,23 @@ export function createSessionService({
     return stopPromise;
   }
 
+  /** Whether the runtime hosting `sessionId` is mid-turn or holds queued input. */
+  function liveSessionBusy(sessionId) {
+    const owner = projection.sessionOwner(sessionId);
+    return Boolean(owner) && retention.stateBusy(owner.runtime?.getState?.());
+  }
+
+  /** Show a transcript notice in the hosted runtime of `sessionId` (no turn)
+   *  and publish it to its views; false when no runtime hosts it. */
+  function pushLiveSessionNotice(sessionId, { text, tone = 'info', ...options } = {}) {
+    const owner = projection.sessionOwner(sessionId);
+    if (typeof owner?.runtime?.pushNotice !== 'function') return false;
+    owner.runtime.pushNotice(text, tone, { ...options, transcript: true });
+    const step = projection.advance(owner);
+    if (step.changed) projection.publishStep(owner, step);
+    return true;
+  }
+
   function getStatus() {
     const busy = retention.liveBusyCount();
     let watched = 0;
@@ -282,6 +299,8 @@ export function createSessionService({
     },
     methods: {
       ...calls,
+      liveSessionBusy,
+      pushLiveSessionNotice,
       stop,
       startQuotaResume: () => quotaResume?.start(),
       runDueQuotaResumes: () => quotaResume?.tick() ?? Promise.resolve(),

package/src/tui/app/slash-commands.mjs

@@ -142,6 +142,26 @@ for (const command of SLASH_COMMANDS) {
   }
 }
 
+/**
+ * The registered command a prompt runs, by the renderer's rule
+ * (apps/desktop renderer/slash-commands.ts recognisedSlashSpan): the text,
+ * trimmed, begins with `/` and its first whitespace-delimited token names a
+ * command or alias. Returns that token lowercased, else null: any other
+ * leading `/` (an absolute path, a stray word) is ordinary message text.
+ */
+export function recognisedSlashToken(text) {
+  const token = /^\s*\/(\S+)/.exec(String(text ?? ''))?.[1].toLowerCase();
+  return token && SLASH_COMMAND_BY_TOKEN.has(token) ? token : null;
+}
+
+/** The only commands a bot's conversation room runs, by their literal name
+ *  (`/new` stays text); mirrors the renderer's recognisedAgentRoomSlash. */
+const AGENT_ROOM_SLASH_TOKENS = new Set(['compact', 'clear']);
+
+export function recognisedAgentRoomSlash(text) {
+  return AGENT_ROOM_SLASH_TOKENS.has(recognisedSlashToken(text));
+}
+
 export function normalizeSlashCommandName(cmd) {
   const name = String(cmd || '').toLowerCase();
   return SLASH_COMMAND_BY_TOKEN.get(name)?.name || name;