mixdog 1.3.0 → 1.3.1

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

@@ -12,6 +12,7 @@ import {
   clearAgentDefinitionCache,
 } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import {
+  BOT_AGENT_KIND,
   canonicalizeAgentRouteStorage,
   isAgentDisabled,
   WORKFLOW_AGENT_KIND,
@@ -43,9 +44,23 @@ function connectorPolicyInput(value) {
   return storedConnectorPolicy(parseConnectorPolicy(value));
 }
 import { STANDALONE_ROOT } from '../runtime-paths.mjs';
+import { homeThreadEvidence } from '../../runtime/shared/agent-kind.mjs';
+import { BOT_SPLIT_BACKUP_DIRS, migrateBotsToOwnStore } from '../../runtime/shared/bot-split-migration.mjs';
+import { backupUserData } from '../../runtime/shared/user-data-guard.mjs';
+import { normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import {
+  botDir,
+  botStoreActive,
+  migratedBotIds,
+  mixyIdentityDir,
+  readBotRoute,
+  readMixyRoute,
+  userDefinitionDir,
+} from '../../runtime/shared/agent-store.mjs';
 
 const isFixedAgent = (id) => FIXED_AGENT_SLOTS.some((agent) => agent.id === id);
-const hasUserAgentFile = (dataDir, id) => existsSync(join(dataDir, 'agents', id, 'AGENT.md'));
+const userDir = userDefinitionDir;
+const hasUserAgentFile = (dataDir, id) => existsSync(join(userDir(dataDir, id), 'AGENT.md'));
 // An archived (deleted) agent's AGENT.md, moved aside beside the tombstone:
 // no loader reads it, and restoring moves it back.
 const ARCHIVED_AGENT_FILE = 'AGENT.md.archived';
@@ -57,28 +72,36 @@ function hiddenFrontmatter(definition) {
   return rest;
 }
 
-// The definition's persisted `kind` marker (isContactAgentId reads it), or
-// null: only the Workflows page's create writes one (`kind: agent`).
+// The definition's kind (isContactAgentId reads it), or null: the explicit
+// marker bot creation (`kind: bot`) or the Workflows page (`kind: agent`)
+// wrote, else the read-only decision for an unmarked one (agent-kind.mjs).
 function kindOf(definition) {
-  const kind = definition?.frontmatter?.kind;
-  return typeof kind === 'string' && kind.trim() ? kind.trim() : null;
+  return definition?.kind || null;
 }
 
-// A save's `kind`: given only when creating, and only as the workflow-agent
-// marker. Unmarked agents are contacts (봇); a kind never changes later.
+// A save's `kind`: given only when creating, as the bot or workflow-agent
+// marker. Unmarked agents are workflow agents; a kind never changes later.
 function creationKind(payload, existed) {
   if (!hasOwn(payload, 'kind')) return null;
   if (existed) throw new Error("an agent's kind is set when it is created and cannot change");
-  if (payload.kind !== WORKFLOW_AGENT_KIND) throw new Error(`agent kind must be "${WORKFLOW_AGENT_KIND}" or absent`);
-  return WORKFLOW_AGENT_KIND;
+  if (payload.kind !== BOT_AGENT_KIND && payload.kind !== WORKFLOW_AGENT_KIND) {
+    throw new Error(`agent kind must be "${BOT_AGENT_KIND}", "${WORKFLOW_AGENT_KIND}" or absent`);
+  }
+  return payload.kind;
 }
 
 function readManifest(dir) {
+  return readManifestStrict(join(dir, 'agent.json')) || {};
+}
+
+// The manifest object at `file`, or null when it is missing, unreadable or
+// not a JSON object.
+function readManifestStrict(file) {
   try {
-    const value = JSON.parse(readFileSync(join(dir, 'agent.json'), 'utf8'));
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    const value = JSON.parse(readFileSync(file, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
   } catch {
-    return {};
+    return null;
   }
 }
 
@@ -238,13 +261,18 @@ function writeAgentFiles(dir, { name, description, body, extra = {}, manifest =
 // user-authored agents are custom definitions under agents/<id>/AGENT.md.
 export function createAgentEditorApi(deps) {
   const { getConfig, loadAgentDefinition, listCustomAgentIds, saveConfigAndAdopt, setAgentRoute } = deps;
-  const routeFor = (config, id) => effectiveAgentRoute(deps, config, id);
+  // A store bot's route lives in its folder; every other agent's in the config.
+  const ownRoute = (config, id) => {
+    const bot = readBotRoute(resolveDataDir(deps), id);
+    return bot !== undefined ? bot : deps.agentRouteFromConfig(config, id);
+  };
+  const routeFor = (config, id) => effectiveAgentRoute({ ...deps, agentRouteFromConfig: ownRoute }, config, id);
   // `route` falls back to Main; this says whether the agent has a route of
   // its own, so a surface never shows (or saves) the Main fallback as one.
-  const routeConfigured = (config, id) => Boolean(deps.agentRouteFromConfig(config, id));
+  const routeConfigured = (config, id) => Boolean(ownRoute(config, id));
   const shippedDir = (id) => join(deps.rootDir ?? STANDALONE_ROOT, 'agents', id);
   // The manifest in effect: the user's own copy if any, else the shipped one.
-  const manifestDirOf = (dataDir, id) => (hasUserAgentFile(dataDir, id) ? join(dataDir, 'agents', id) : shippedDir(id));
+  const manifestDirOf = (dataDir, id) => (hasUserAgentFile(dataDir, id) ? userDir(dataDir, id) : shippedDir(id));
   const manifestOf = (dataDir, id) => readManifest(manifestDirOf(dataDir, id));
   const avatarOf = (dataDir, id) => normalizeAgentAvatar(manifestOf(dataDir, id).avatar);
   // A saved, archived or restored bot reaches the prompts that embed it: the
@@ -292,7 +320,7 @@ export function createAgentEditorApi(deps) {
   // writes, from the copy in effect. An editor that loaded it can send it back
   // as `expectedRevision`, and a save over a newer copy is refused.
   function definitionRevision(dataDir, id) {
-    const dir = hasUserAgentFile(dataDir, id) ? join(dataDir, 'agents', id) : shippedDir(id);
+    const dir = hasUserAgentFile(dataDir, id) ? userDir(dataDir, id) : shippedDir(id);
     const hash = createHash('sha256');
     for (const name of ['agent.json', 'AGENT.md', PERSONA_FILE]) {
       hash.update(`${name}\0`);
@@ -326,7 +354,7 @@ export function createAgentEditorApi(deps) {
       kind: kindOf(definition),
       disabled: isAgentDisabled(getConfig(), id),
       avatar: avatarOf(dataDir, id),
-      persona: readPersona(hasUserAgentFile(dataDir, id) ? join(dataDir, 'agents', id) : shippedDir(id)),
+      persona: readPersona(hasUserAgentFile(dataDir, id) ? userDir(dataDir, id) : shippedDir(id)),
       revision: definitionRevision(dataDir, id),
     };
   }
@@ -345,7 +373,14 @@ export function createAgentEditorApi(deps) {
         id ||
         availableAgentId(
           name,
-          (candidate) => Boolean(loadAgentDefinition(dataDir, candidate)) || isArchivedAgent(dataDir, candidate)
+          (candidate) =>
+            Boolean(loadAgentDefinition(dataDir, candidate)) ||
+            isArchivedAgent(dataDir, candidate) ||
+            // An id the split copied stays the bot's, even once purged; a
+            // folder in either store keeps its id too.
+            migratedBotIds(dataDir).has(candidate) ||
+            (botStoreActive(dataDir) &&
+              (existsSync(join(dataDir, 'agents', candidate)) || existsSync(botDir(dataDir, candidate))))
         ),
       name,
       description: oneLine(payload.description),
@@ -371,7 +406,21 @@ export function createAgentEditorApi(deps) {
     const kind = creationKind(payload, existed);
     const definition = { name: name || id, description, body };
     const manifest = hiddenManifest(manifestOf(dataDir, id));
-    const dir = join(dataDir, 'agents', id);
+    // With the bot store, a new bot is made in bots/ and a new agent in
+    // agents/; either keeps its `kind` marker, so its kind never rests on
+    // the folder alone (a copy read without the store is still a bot).
+    const storeBot = !existed && kind === BOT_AGENT_KIND && botStoreActive(dataDir);
+    // An id is one definition's in one store: a new bot never takes an id
+    // agents/ holds (an archived agent's included), a new agent never one of
+    // bots/ (or one the split moved there, even if since deleted).
+    if (!existed && botStoreActive(dataDir)) {
+      const taken = storeBot
+        ? existsSync(join(dataDir, 'agents', id))
+        : existsSync(botDir(dataDir, id)) || migratedBotIds(dataDir).has(id);
+      if (taken) throw new Error(`agent id "${id}" is already in use; pick another name`);
+    }
+    const dir = storeBot ? botDir(dataDir, id) : userDir(dataDir, id);
+    const inStore = dir === botDir(dataDir, id);
     // New custom images arrive as checked bytes, stored under content hashes.
     const update = hasOwn(payload, 'avatar') ? avatarUpdate(payload.avatar, dir) : null;
     if (update?.avatar) manifest.avatar = update.avatar;
@@ -389,6 +438,7 @@ export function createAgentEditorApi(deps) {
     // Equal to the shipped agent: keep no copy so it follows the shipped
     // version — unless the manifest (an avatar) or a persona differs.
     const absorbed =
+      !inStore &&
       !persona &&
       stableJson(manifest) === stableJson(hiddenManifest(readManifest(shippedDir(id)))) &&
       absorbSaveEqualToShipped({
@@ -440,7 +490,7 @@ export function createAgentEditorApi(deps) {
     if (isHiddenAgent(id)) throw new Error(`agent "${id}" is internal and cannot be deleted`);
     const builtIn = isFixedAgent(id);
     const dataDir = resolveDataDir(deps);
-    const dir = join(dataDir, 'agents', id);
+    const dir = userDir(dataDir, id);
     if (!hasUserAgentFile(dataDir, id)) {
       if (builtIn) throw new Error(`agent "${id}" has no user override to reset`);
       if (!loadAgentDefinition(dataDir, id)) throw new Error(`agent "${id}" not found`);
@@ -470,7 +520,7 @@ export function createAgentEditorApi(deps) {
     return { id, deleted: true, revertedToBuiltIn: false };
   }
 
-  const isArchivedAgent = (dataDir, id) => existsSync(join(dataDir, 'agents', id, AGENT_DELETED_MARKER));
+  const isArchivedAgent = (dataDir, id) => existsSync(join(userDir(dataDir, id), AGENT_DELETED_MARKER));
 
   /** An archived agent back as it was, under its own id: its AGENT.md moved
    *  back (a starter without a copy of its own returns to the packaged one)
@@ -480,7 +530,7 @@ export function createAgentEditorApi(deps) {
     if (!id || isHiddenAgent(id) || isFixedAgent(id)) throw new Error(`unknown agent "${agentId}"`);
     const dataDir = resolveDataDir(deps);
     if (!isArchivedAgent(dataDir, id)) throw new Error(`agent "${id}" is not deleted`);
-    const dir = join(dataDir, 'agents', id);
+    const dir = userDir(dataDir, id);
     const kept = join(dir, ARCHIVED_AGENT_FILE);
     if (!existsSync(kept) && !existsSync(join(shippedDir(id), 'AGENT.md'))) {
       throw new Error(`agent "${id}" was deleted before deleted agents were kept, so it cannot be restored`);
@@ -501,7 +551,7 @@ export function createAgentEditorApi(deps) {
     const dataDir = resolveDataDir(deps);
     // Never a live agent; one deleted before archiving existed left nothing.
     if (!isArchivedAgent(dataDir, id)) return { id, purged: false };
-    const dir = join(dataDir, 'agents', id);
+    const dir = userDir(dataDir, id);
     rmSync(dir, { recursive: true, force: true });
     clearAgentDefinitionCache(id);
     dropAgentRoute(id);
@@ -522,7 +572,7 @@ export function createAgentEditorApi(deps) {
       ids.map((agentId) => {
         const id = agentEditorId(agentId);
         if (!id || id !== agentId || !isArchivedAgent(dataDir, id)) return [agentId, null];
-        const manifest = readManifest(join(dataDir, 'agents', id));
+        const manifest = readManifest(userDir(dataDir, id));
         return [agentId, { name: oneLine(manifest.name) || id, avatar: normalizeAgentAvatar(manifest.avatar) ?? null }];
       })
     );
@@ -547,9 +597,9 @@ export function createAgentEditorApi(deps) {
     const presence = (agentId) => {
       const id = agentEditorId(agentId);
       if (!id || id !== agentId) return 'unknown';
-      const user = probe(join(dataDir, 'agents', id, 'AGENT.md'));
+      const user = probe(join(userDir(dataDir, id), 'AGENT.md'));
       if (user !== 'absent') return user;
-      const tombstone = probe(join(dataDir, 'agents', id, AGENT_DELETED_MARKER));
+      const tombstone = probe(join(userDir(dataDir, id), AGENT_DELETED_MARKER));
       if (tombstone === 'present') return 'deleted';
       if (tombstone === 'unknown') return 'unknown';
       const shipped = probe(join(rootDir, 'agents', id, 'AGENT.md'));
@@ -566,9 +616,10 @@ export function createAgentEditorApi(deps) {
     const id = agentEditorId(agentId);
     if (!id || isHiddenAgent(id)) return null;
     const dataDir = resolveDataDir(deps);
-    // Mixy's face lives in agents/lead/agent.json, beside no AGENT.md of its own.
+    // Mixy's face lives in its identity folder's agent.json (mixyIdentityDir:
+    // bots/mixy with the bot store, agents/lead before), beside no AGENT.md.
     const lead = id === LEAD_AGENT_ID;
-    const dir = join(dataDir, 'agents', id);
+    const dir = lead ? leadDir() : userDir(dataDir, id);
     // An archived agent's face stays readable for its archived chat.
     const archived = !lead && isArchivedAgent(dataDir, id);
     const avatar = lead
@@ -587,8 +638,10 @@ export function createAgentEditorApi(deps) {
 
   // Mixy (the Lead) has no agent definition to edit: only its PERSONA.md
   // (성격) and AGENT.md (일하는 방식, agent mode only), read by the runtime
-  // from agents/lead/. Saved empty, the file goes.
-  const leadDir = () => join(resolveDataDir(deps), 'agents', LEAD_AGENT_ID);
+  // from Mixy's identity folder: bots/mixy once the bot store is active,
+  // agents/lead before (mixyIdentityDir, agent-store.mjs). Saved empty, the
+  // file goes.
+  const leadDir = () => mixyIdentityDir(resolveDataDir(deps));
   function readLeadFile(file) {
     try {
       return readFileSync(join(leadDir(), file), 'utf8').trim();
@@ -614,16 +667,27 @@ export function createAgentEditorApi(deps) {
   const saveLeadAgentBody = (text) => saveLeadFile('AGENT.md', text);
 
   // Whether Mixy was created (the "대표 에이전트 만들기" first run): the
-  // explicit `created` flag in agents/lead/agent.json. null until decided —
+  // explicit `created` flag in Mixy's agent.json (leadDir). null until decided —
   // the desktop host decides once (an existing profile counts as created).
   // Also Mixy's display name (`name`, read by the runtime's identity line) and
   // face (`avatar`, as every agent manifest): '' / null mean the defaults.
+  // `homeChatted`: whether Mixy's home thread holds any conversation (the
+  // host reads it to tell v1.3.0's never-used automatic Mixy apart).
   function getLeadStatus() {
     const manifest = readManifest(leadDir());
+    // A v1.3.0 automatic Mixy the split left in agents/lead still counts as
+    // decided (its routines keep running) until bots/mixy says otherwise.
+    const legacy = readManifest(join(resolveDataDir(deps), 'agents', LEAD_AGENT_ID)).created;
+    let created = null;
+    if (typeof manifest.created === 'boolean') created = manifest.created;
+    else if (typeof legacy === 'boolean') created = legacy;
     return {
-      created: typeof manifest.created === 'boolean' ? manifest.created : null,
+      created,
       name: oneLine(manifest.name),
       avatar: normalizeAgentAvatar(manifest.avatar) ?? null,
+      homeChatted: homeThreadEvidence(resolveDataDir(deps), LEAD_AGENT_ID).chatted,
+      // Mixy's own model (never the Lead's); null: its thread keeps its own.
+      route: readMixyRoute(resolveDataDir(deps)),
     };
   }
   // Mixy's name and face, chosen in the 대표 에이전트 dialog or its profile:
@@ -648,8 +712,15 @@ export function createAgentEditorApi(deps) {
     return getLeadStatus();
   }
   // Sets the flag (and Mixy's 하는 일 when given); every other key is kept.
+  // A Lead manifest that exists but cannot be read as an object is the
+  // user's and is left alone: nothing is written, the status stays as read.
   function setLeadCreated(created, description) {
     if (typeof created !== 'boolean') throw new TypeError('created must be a boolean');
+    const file = join(leadDir(), 'agent.json');
+    if (existsSync(file) && !readManifestStrict(file)) {
+      process.stderr.write(`[agents] ${file} is not a readable JSON object; Mixy's created flag was not saved\n`);
+      return getLeadStatus();
+    }
     const manifest = readManifest(leadDir());
     manifest.created = created;
     const job = oneLine(description);
@@ -691,7 +762,27 @@ export function createAgentEditorApi(deps) {
     return getAgentConnectorPolicy(id);
   }
 
+  /** The one-time split of bots into bots/ (bot-split-migration.mjs), from
+   *  the config as it is now; the catalogs read the store from here on. */
+  function migrateBotStore() {
+    const dataDir = resolveDataDir(deps);
+    const config = getConfig();
+    const result = migrateBotsToOwnStore({
+      dataDir,
+      shippedRoot: deps.rootDir ?? STANDALONE_ROOT,
+      routeOf: (id) => deps.agentRouteFromConfig(config, id),
+      leadRoute: normalizeWorkflowRoute(deps.resolveRoute(config, {})),
+      // The definitions the split copies or a re-sync replaces go with it.
+      backup: () => backupUserData(dataDir, 'bot-split', { dirs: BOT_SPLIT_BACKUP_DIRS }),
+      log: (line) => process.stderr.write(`${line}\n`),
+    });
+    clearAgentDefinitionCache();
+    listCustomAgentIds?.(dataDir);
+    return result;
+  }
+
   return {
+    migrateBotStore,
     getAgentConnectorPolicy,
     setAgentConnectorPolicy,
     listAgents,

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/standalone/daemon-session-control.mjs

@@ -1,6 +1,7 @@
 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']);
@@ -51,15 +52,22 @@ export function createSessionControl({
       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) };
+      // 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

@@ -96,6 +96,7 @@ 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 {
   compareRuntimeVersions,
@@ -926,6 +927,8 @@ async function main() {
     cwd: CWD,
   });
   canonicalAgentControl = agentControl;
+  // 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();
@@ -939,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
@@ -986,9 +989,16 @@ async function main() {
   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 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,
@@ -997,6 +1007,8 @@ async function main() {
   // 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

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 : '';