mixdog 1.2.6 → 1.3.1

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

@@ -4,8 +4,22 @@ import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.
 import { normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { ensureProviderEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { resolveRouteContextState, selectionFastCapable } from '../route-state.mjs';
-import { canonicalizeAgentRouteStorage, withAgentDisabled } from '../../runtime/shared/agent-route-config.mjs';
-import { agentEditorId } from './shared.mjs';
+import {
+  canonicalizeAgentRouteStorage,
+  isAgentDisabled,
+  withAgentDisabled,
+} from '../../runtime/shared/agent-route-config.mjs';
+import { agentEditorId, resolveDataDir } from './shared.mjs';
+import {
+  isStoreBot,
+  readBotRoute,
+  readMixyRoute,
+  writeBotRoute,
+  writeMixyRoute,
+} from '../../runtime/shared/agent-store.mjs';
+
+/** 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';
 
 // Agent route persistence. Route-scope isolation: an agent route owns its
@@ -23,8 +37,35 @@ export function createAgentRouteApi(deps) {
     saveConfigAndAdopt(canonicalizeAgentRouteStorage(withAgentDisabled(getConfig(), id, disabled)));
   }
 
+  // A bot of the store keeps its route in its own folder (agent-store.mjs);
+  // Mixy (`lead` here, its runtime id) keeps its own in bots/mixy — never the
+  // Lead's route, which the Main route setter owns.
+  const dataDir = () => (deps.cfgMod || deps.STANDALONE_DATA_DIR ? resolveDataDir(deps) : '');
+  const isMixy = (id) => id === MIXY_RUNTIME_ID && Boolean(dataDir());
+  const storeBot = (id) => isStoreBot(dataDir(), id);
+  function saveRoute(id, route, keepOff) {
+    if (isMixy(id)) {
+      writeMixyRoute(dataDir(), route);
+      return;
+    }
+    if (storeBot(id)) {
+      writeBotRoute(dataDir(), id, route);
+      saveDisabled(id, keepOff);
+      return;
+    }
+    const nextConfig = withAgentDisabled(getConfig(), id, keepOff);
+    nextConfig.agents = { ...(nextConfig.agents || {}), [id]: route };
+    saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
+  }
+
   // Only an explicitly empty provider removes an override: the agent inherits Main.
   function clearOverride(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 };
+    }
     const nextConfig = { ...getConfig() };
     const agents = { ...(nextConfig.agents || {}) };
     const hadOverride = Object.hasOwn(agents, id);
@@ -83,7 +124,20 @@ export function createAgentRouteApi(deps) {
     if (!id) throw new Error(`unknown agent "${agentId}"`);
     if (isHiddenAgent(id)) throw new Error(`agent "${id}" is internal and has no configurable route`);
     const requested = { ...(next || {}) };
-    const stored = agentRouteFromConfig(getConfig(), id) || {};
+    // Compare-and-set: fill the route only while the agent has none. A route
+    // 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 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;
     // 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.
@@ -126,11 +180,17 @@ export function createAgentRouteApi(deps) {
     const [primary, ...fallbacks] = resolved;
     const routeToSave = normalizeWorkflowRoute({ ...primary, fallbacks });
     if (!routeToSave) throw new Error('agent route requires provider and model');
+    // No await from here to the write: the emptiness checked is the emptiness
+    // written over. An off agent stays off when it was only back-filled.
+    // A store bot's or Mixy's route is read from its folder on disk right here.
+    // An agent routed in the config file may have been written by another
+    // process whose change notification is still pending: re-read it first.
+    if (onlyIfEmpty && !isMixy(id) && !storeBot(id)) deps.reloadFullConfig?.();
+    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 nextConfig = withAgentDisabled(getConfig(), id, keepOff);
-    nextConfig.agents = { ...(nextConfig.agents || {}), [id]: routeToSave };
-    saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
-    return keepOff ? { ...routeToSave, id, disabled: true } : routeToSave;
+    saveRoute(id, routeToSave, stayOff);
+    return stayOff ? { ...routeToSave, id, disabled: true } : routeToSave;
   }
 
   return { setAgentRoute };

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

@@ -25,6 +25,7 @@ function applyWorkflowSlots(workflowInput, draft) {
       if (!normalized) continue;
       draft.presets = upsertWorkflowPreset(draft.presets, 'lead', normalized);
       draft.defaultPreset = workflowPresetId('lead');
+      draft.leadRoute = normalized;
     } else if (slot === 'agent') {
       if (normalized) draft.agentRoutes.worker = normalized;
       else delete draft.agentRoutes.worker;
@@ -72,10 +73,13 @@ export function createOnboardingApi(deps) {
         presets: Array.isArray(nextConfig.presets) ? nextConfig.presets.slice() : [],
         defaultPreset: nextConfig.default,
         agentRoutes: { ...(nextConfig.agents || {}) },
+        // The Lead route this save writes, from `defaultRoute` or `workflowRoutes.lead`.
+        leadRoute: null,
       };
       if (defaultRoute) {
         draft.presets = upsertWorkflowPreset(draft.presets, 'lead', defaultRoute);
         draft.defaultPreset = workflowPresetId('lead');
+        draft.leadRoute = defaultRoute;
       }
       const workflowInput =
         payload.workflowRoutes && typeof payload.workflowRoutes === 'object' ? payload.workflowRoutes : {};
@@ -104,12 +108,15 @@ export function createOnboardingApi(deps) {
       }
 
       saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
-      if (defaultRoute) {
+      // Whatever wrote the Lead route also moves the runtime Main route, in the
+      // same synchronous step as the save: a pending conditional backfill then
+      // finds a route that is not empty instead of overwriting this choice.
+      if (draft.leadRoute) {
         setRouteState(
           resolveRoute(getConfig(), {
-            provider: defaultRoute.provider,
-            model: defaultRoute.model,
-            effort: defaultRoute.effort,
+            provider: draft.leadRoute.provider,
+            model: draft.leadRoute.model,
+            effort: draft.leadRoute.effort,
           })
         );
         deps.invalidatePreSessionToolSurface?.();

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,27 @@
 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';
+import { handoffContent } from '../session-runtime/handoff-attachments.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,12 +52,22 @@ export function createSessionControl({ getSessionService }) {
       if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
         throw new Error('session: prompt is required for action=send');
       }
+      // An agent conversation's send reports its turn back to the agent's
+      // home: a task session it created by its stored origin, any other
+      // session by an origin for this send only.
+      // Forwarded files ride along as stored attachment parts (workspace-tools.mjs).
+      const prompt = handoffContent(args.prompt, context.attachmentParts);
+      const origin = await agentTasks.reportOrigin(sessionId, context.callerAgentId, caller);
+      if (origin) {
+        const { accepted, reportsBack } = await agentTasks.send(sessionId, prompt, origin);
+        return { sessionId, accepted, reportsBack };
+      }
       const result = await service.submitSession({
         sessionId,
-        prompt: args.prompt,
+        prompt,
         options: { mode: 'prompt', transcriptMeta: { sender: 'lead' } },
       });
-      return { sessionId, accepted: result.accepted === true };
+      return { sessionId, accepted: result.accepted === true, reportsBack: false };
     }
     if (action === 'cancel') {
       const result = await service.abortSession({ sessionId });

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';
@@ -94,8 +96,8 @@ import { createChannelsRuntimeLoader } from './daemon-channels-loader.mjs';
 import { createDesktopRuntime } from './daemon-desktop-runtime.mjs';
 import { createCanonicalAgentControl } from './daemon-agent-control.mjs';
 import { createSessionControl } from './daemon-session-control.mjs';
+import { createAgentTaskSessions } from '../session-runtime/agent-task-sessions.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 +927,8 @@ 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);
+  // Agents' cross-session sends and task sessions, and their report watches.
+  const agentTasks = createAgentTaskSessions({ getSessionService: () => sessionService });
   const requestedRuntimeMode = String(process.env.MIXDOG_SESSION_RUNTIME_MODE || '')
     .trim()
     .toLowerCase();
@@ -941,7 +942,7 @@ async function main() {
     log,
     measureBootPhase: bootPhases.measure,
     executeAgentControl: agentControl.execute,
-    executeSessionControl: createSessionControl({ getSessionService: () => sessionService }),
+    executeSessionControl: createSessionControl({ getSessionService: () => sessionService, agentTasks }),
   });
   // Codex-style runtime: daemon routing and independent async session actors
   // share one V8 isolate and module graph. CPU-heavy work stays in bounded
@@ -984,6 +985,31 @@ 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. Resolves whether the turn was taken.
+    wake: async (sessionId, prompt, { id } = {}) =>
+      (
+        await sessionService.submitSession({
+          sessionId,
+          prompt,
+          options: { mode: 'prompt', kickoff: true, ...(id ? { id } : {}) },
+        })
+      )?.accepted === 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}`));
+  // Agents' sends whose report an earlier process had not queued yet.
+  agentTasks.recover().catch((error) => log(`agent task report 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/agent-tree/agent-turns.mjs

@@ -4,6 +4,43 @@
 import { randomUUID } from 'node:crypto';
 import { createAgentChildFactory } from './agent-child.mjs';
 import { partialHandoffTextFromSession } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+import { attachmentsForIntake } from '../../../runtime/attachments/store.mjs';
+import { artifactLines } from '../../../runtime/shared/handoff-artifacts.mjs';
+import { collectTurnArtifacts, handoffContent, sessionRoots } from '../../../session-runtime/handoff-attachments.mjs';
+
+/** An agent turn's prompt: text, or text with forwarded attachment parts
+ *  (handoff-attachments.mjs), never any other shape. */
+export function agentTurnContent(prompt) {
+  if (!Array.isArray(prompt)) return String(prompt || '');
+  const text = prompt
+    .filter((part) => part?.type === 'text' && !part.attachmentRef)
+    .map((part) => String(part.text || ''))
+    .join('\n');
+  return handoffContent(text, prompt);
+}
+
+/** The prompt row's metadata: a Lead's message, with the files it carries. */
+export function agentTurnTranscriptMeta(content) {
+  const attachments = Array.isArray(content) ? attachmentsForIntake(content) : [];
+  return { sender: 'lead', ...(attachments.length ? { attachments } : {}) };
+}
+
+/** The artifact lines of the turn that began at `messageStart`; [] on any
+ *  failure to read it (the handoff still goes out). */
+async function turnArtifactLines(runtime, messageStart, descriptor) {
+  try {
+    const { messages } = await runtime.readModelMessages(messageStart);
+    const session = runtime.session || descriptor;
+    const { files, omitted } = collectTurnArtifacts(messages, {
+      cwd: descriptor.cwd,
+      roots: sessionRoots(session, descriptor.cwd),
+    });
+    // Text only: the caller forwards these by path (an id in text is never trusted).
+    return artifactLines(files, omitted, { ids: false });
+  } catch {
+    return [];
+  }
+}
 
 export function createAgentTurns({
   registry,
@@ -67,15 +104,16 @@ export function createAgentTurns({
     descriptor.stage = 'running';
     descriptor.updatedAt = Date.now();
     try {
+      const content = agentTurnContent(prompt);
       const options = {
         id: `agent-turn-${randomUUID()}`,
         mode: 'prompt',
         priority: 'next',
         context,
-        transcriptMeta: { sender: 'lead' },
+        transcriptMeta: agentTurnTranscriptMeta(content),
         ...(entry.runtime.isWireSafe === true || typeof onToolResult !== 'function' ? {} : { onToolResult }),
       };
-      const detail = await target.call(entry.runtime, String(prompt || ''), options);
+      const detail = await target.call(entry.runtime, content, options);
       if (detail?.status === 'failed') {
         throw new Error(String(detail.error || 'agent session turn failed'));
       }
@@ -91,7 +129,12 @@ export function createAgentTurns({
         const reason = String(detail?.reason || detail?.error || '').trim();
         throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
-      const result = detail?.result || { content: '' };
+      let result = detail?.result || { content: '' };
+      // The files the turn produced reach the owner with its handoff.
+      const files = await turnArtifactLines(entry.runtime, messageStart, descriptor);
+      if (files.length) {
+        result = { ...result, content: [String(result.content || ''), files.join('\n')].join('\n\n') };
+      }
       descriptor.status = 'idle';
       descriptor.stage = 'idle';
       descriptor.lastHandoff = typeof result?.content === 'string' ? result.content : '';

package/src/standalone/session-service/agent-tree.mjs

@@ -10,7 +10,7 @@
 import { createAgentCancellation } from './agent-tree/agent-cancel.mjs';
 import { createAgentRegistry } from './agent-tree/agent-registry.mjs';
 import { createAgentRehydration, lastStoredAgentHandoff } from './agent-tree/agent-rehydrate.mjs';
-import { createAgentTurns } from './agent-tree/agent-turns.mjs';
+import { agentTurnContent, agentTurnTranscriptMeta, createAgentTurns } from './agent-tree/agent-turns.mjs';
 import { randomUUID } from 'node:crypto';
 
 export { SESSION_ID_PATTERN } from './agent-tree/agent-registry.mjs';
@@ -139,12 +139,13 @@ export function createAgentTree({
       const cancelEpoch = registry.assertAdmission(descriptor.id);
       const runtime = sessionOwner(descriptor.id)?.runtime;
       if (!runtime || !stateBusy(runtime.getState())) return null;
-      const accepted = await runtime.submitAsync(String(prompt || ''), {
+      const content = agentTurnContent(prompt);
+      const accepted = await runtime.submitAsync(content, {
         id: `agent-message-${randomUUID()}`,
         mode: 'prompt',
         priority: 'next',
         context,
-        transcriptMeta: { sender: 'lead' },
+        transcriptMeta: agentTurnTranscriptMeta(content),
       });
       if (accepted === false) throw new Error('agent follow-up was not accepted');
       registry.assertAdmission(descriptor.id, cancelEpoch);

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

@@ -11,6 +11,10 @@ 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 { isAgentHomeSessionId } from '../../../runtime/agent/orchestrator/session/agent-home.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
@@ -35,6 +39,17 @@ function abortsAgentTurn(id, state, hasAgentSession) {
   );
 }
 
+/** A prompt the user typed: not an agent's send (`sender: 'lead'`), a hidden
+ *  wake, a routine fire or any other runtime-made turn. */
+export function isUserTurn(options = {}) {
+  return (
+    (options.mode || 'prompt') === 'prompt' &&
+    options.kickoff !== true &&
+    options.isMeta !== true &&
+    options.transcriptMeta?.sender !== 'lead'
+  );
+}
+
 export function createSessionTurnCalls(ctx) {
   const { log, readStoredGoal, listStoredActiveGoalSessionIds, hasAgentSession, sessionResult, advanceForCaller } = ctx;
   const { retainUnwatched } = ctx.retention;
@@ -76,9 +91,22 @@ 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;
+      if (isAgentHomeSessionId(id) && isUserTurn(submissionOptions)) {
+        // The user spoke in this agent's home: its round trips with other
+        // sessions count from zero again, so a capped thread wakes again.
+        void import('../../../session-runtime/agent-home-delivery.mjs')
+          .then(({ resetAgentTaskRounds }) => resetAgentTaskRounds(id))
+          .catch((error) => log(`round reset of ${id} failed: ${error?.message || error}`));
+      }
     }
     const step = settleAction(entry, 'headless session submit');
     log(`session submit session=${id} accepted=${accepted === true}`);

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;