mixdog 1.3.0 → 1.3.1

package/src/session-runtime/agent-room-delivery.mjs

@@ -10,9 +10,12 @@
 import {
   normalizeRoomRow,
   roomIdOfSession,
+  roomMemberOfSession,
   roomRowItem,
   roomRowMessage,
 } from '../runtime/agent/orchestrator/session/agent-room.mjs';
+import { artifactRecords } from '../runtime/shared/handoff-artifacts.mjs';
+import { collectTurnArtifacts, sessionRoots, turnSlice } from './handoff-attachments.mjs';
 import {
   attachmentsForIntake,
   isAttachmentReference,
@@ -46,14 +49,52 @@ async function storedRow(row) {
   };
 }
 
+/** A member's speech with the files its turn produced taken in: `artifactsFrom`
+ *  `{ sessionId, since }` names the member's own session in this room and when
+ *  its turn started; the files inside that session's folders are stored and
+ *  ride on the row as references (handoff-attachments.mjs). */
+function speechWithArtifacts(row, roomId, loadSession, log) {
+  const from =
+    row?.kind === 'speech' && row.artifactsFrom && typeof row.artifactsFrom === 'object' ? row.artifactsFrom : null;
+  if (!from) return row;
+  const { artifactsFrom: _from, ...rest } = row;
+  const member = roomMemberOfSession(String(from.sessionId || ''));
+  if (!member || member.roomId !== roomId || member.agentId !== row.speaker) return rest;
+  try {
+    const session = loadSession(from.sessionId);
+    const messages = turnSlice(session?.messages, { since: Number(from.since) || 0 });
+    const { files } = collectTurnArtifacts(messages, { cwd: session?.cwd, roots: sessionRoots(session) });
+    const stored = files.filter((file) => file.id);
+    if (!stored.length) return rest;
+    return {
+      ...rest,
+      parts: stored.map((file) => ({
+        type: file.kind === 'image' ? 'image' : file.kind === 'text' ? 'text' : 'file',
+        attachmentRef: file.id,
+        ...(file.kind === 'text' ? { textKind: 'file' } : {}),
+        mimeType: file.mimeType,
+        filename: file.name,
+        sizeBytes: file.size,
+      })),
+      attachments: artifactRecords(stored),
+    };
+  } catch (error) {
+    log(`the files of ${from.sessionId} could not be taken in: ${error?.message || error}`);
+    return rest;
+  }
+}
+
 export function createAgentRoomDelivery({ loadSession, saveSession, live = agentHomeLiveSurface, log = () => {} }) {
   /** Append `rows` to the log of `sessionId`; resolves `{ added, rows }`: how
    *  many were new, and every row as stored (files as references, no bytes). */
   async function append(sessionId, rows) {
-    if (!roomIdOfSession(sessionId)) throw new TypeError('not a group-room session');
-    const kept = (await Promise.all((Array.isArray(rows) ? rows : []).map(storedRow))).map((row) =>
-      normalizeRoomRow(row)
-    );
+    const roomId = roomIdOfSession(sessionId);
+    if (!roomId) throw new TypeError('not a group-room session');
+    const kept = (
+      await Promise.all(
+        (Array.isArray(rows) ? rows : []).map((row) => storedRow(speechWithArtifacts(row, roomId, loadSession, log)))
+      )
+    ).map((row) => normalizeRoomRow(row));
     const messages = kept.map((row) => roomRowMessage(row));
     const session = loadSession(sessionId);
     if (!session || session.closed === true) throw new Error(`session ${sessionId} is not available`);

package/src/session-runtime/agent-task-sessions.mjs

@@ -9,11 +9,19 @@
  * home (agent-home-delivery.mjs), which posts it and wakes the agent once to
  * relay it. A turn blocked on the user's answer or approval posts one faint
  * line instead; the card stays in the task session for the user.
+ *
+ * An agent's send to any other session reports the same way, by an origin for
+ * that send only (reportOrigin). Every reporting turn is also watched durably
+ * (agent-home-delivery.mjs `watches`) until its end is queued, so a daemon
+ * restart before that re-attaches it (recover): an ended turn reports once
+ * from the target's record, a queued or running one is watched to its end.
  */
 import { randomUUID } from 'node:crypto';
 import { realpathSync, statSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { collectTurnArtifacts, handoffContent, sessionRoots, turnSlice } from './handoff-attachments.mjs';
+import { roomMemberOfSession } from '../runtime/agent/orchestrator/session/agent-room.mjs';
 
 const TITLE_LIMIT = 60;
 
@@ -51,9 +59,72 @@ export function resolveTaskProject(project, { projects = [], cwd = process.cwd()
 const turnStatus = (detail) =>
   ({ done: 'completed', completed: 'completed', failed: 'failed' })[detail?.status] || 'cancelled';
 
+const INTERRUPTED = /^\[Request interrupted/;
+
+const messageText = (content) =>
+  typeof content === 'string'
+    ? content
+    : (Array.isArray(content) ? content : [])
+        .map((part) => (typeof part === 'string' ? part : part?.type === 'text' ? part.text || '' : ''))
+        .join('');
+
+/** The submissions a stored user message delivered: a turn's prompt
+ *  (`checkpointId`, `submissionIds` of a merged batch) or a steered message. */
+export function submissionIdsOf(message) {
+  if (message?.role !== 'user') return [];
+  const meta = message.meta || {};
+  const transcript = meta.transcript || {};
+  return [
+    transcript.checkpointId,
+    ...(Array.isArray(transcript.submissionIds) ? transcript.submissionIds : []),
+    ...(Array.isArray(meta.submissionIds) ? meta.submissionIds : []),
+  ];
+}
+
+/** The end of the turn that took submission `runId`, from a session's stored
+ *  `messages`: `{ status, text }` once that turn recorded its end (its
+ *  completion, an interruption marker, or the next turn's prompt), 'open'
+ *  while it has none, null when no turn took it. */
+export function submissionOutcome(messages, runId) {
+  const list = Array.isArray(messages) ? messages : [];
+  const start = list.findIndex((message) => submissionIdsOf(message).includes(runId));
+  if (start < 0) return null;
+  for (let index = start; index < list.length; index += 1) {
+    const message = list[index];
+    const completion = message?.meta?.transcript?.completion;
+    if (completion) {
+      const status = turnStatus(completion);
+      const text = status === 'failed' ? completion.detail || '' : message.role === 'assistant' ? message.content : '';
+      return { status, text: messageText(text) };
+    }
+    if (index === start || message?.role !== 'user') continue;
+    if (INTERRUPTED.test(messageText(message.content)) || message.meta?.transcript?.checkpointId) {
+      return { status: 'cancelled', text: '' };
+    }
+  }
+  return 'open';
+}
+
+const LOST_TEXT = 'The message never ran: the app restarted before its turn started.';
+const GONE_TEXT = 'The session no longer exists.';
+
+// The last-used model search stops after this many catalog pages.
+const LAST_USED_ROUTE_MAX_PAGES = 20;
+
 export function createAgentTaskSessions({
   getSessionService,
   deliver = async (agentId, report) => (await import('./agent-home-delivery.mjs')).deliverAgentTask(agentId, report),
+  // The durable watch of each reporting turn until its end is queued.
+  watches = {
+    add: async (watch) => (await import('./agent-home-delivery.mjs')).watchAgentTask(watch),
+    list: async () => (await import('./agent-home-delivery.mjs')).agentTaskWatches(),
+    remove: async (runId) => (await import('./agent-home-delivery.mjs')).unwatchAgentTask(runId),
+  },
+  // Submissions still queued (durably) for a session after a restart.
+  queuedSubmissionIds = async (sessionId) =>
+    (await (await import('../tui/session/tui-steering-persist.mjs')).readTuiSteeringPersist(sessionId))
+      .map((row) => row?.submissionId)
+      .filter(Boolean),
   loadSession = async (sessionId) =>
     (await import('../runtime/agent/orchestrator/session/store.mjs')).loadSession(sessionId),
   listProjects = async () => (await import('../runtime/shared/projects.mjs')).listProjects(),
@@ -73,8 +144,56 @@ export function createAgentTaskSessions({
     if (!preset) throw new Error(`model "${ref}" is neither a provider/model route nor a known preset name`);
     return modelRouteFields(preset);
   },
+  // The Lead (Main) route of the config — what a desktop New task starts on.
+  // Null while none is chosen.
+  leadRoute = async () => {
+    const [{ modelRouteFields }, { resolveRoute }, { loadConfig }] = await Promise.all([
+      import('../runtime/shared/schedule-model-ref.mjs'),
+      import('./boot/shared.mjs'),
+      import('../runtime/agent/orchestrator/config.mjs'),
+    ]);
+    const route = resolveRoute(loadConfig({ secrets: false }), {});
+    return clean(route?.provider) && clean(route?.model) ? modelRouteFields(route) : null;
+  },
+  // The model the user last used in a coding session (the runtime's stand-in
+  // for the desktop's last New-task model): the first row that has one in the
+  // catalog, which lists newest activity first. Pages on (bounded) until a
+  // row qualifies; null when none does.
+  lastUsedRoute = async (sessionService) => {
+    let cursor = null;
+    for (let page = 0; page < LAST_USED_ROUTE_MAX_PAGES; page += 1) {
+      const listed = await sessionService.listSessionCatalog({ page: { limit: 50, cursor } });
+      const used = (Array.isArray(listed?.sessions) ? listed.sessions : []).find(
+        (row) => row?.sessionMode !== 'agent' && clean(row?.provider) && clean(row?.model)
+      );
+      if (used) return { provider: clean(used.provider), model: clean(used.model) };
+      cursor = listed?.nextCursor || null;
+      if (!cursor) return null;
+    }
+    return null;
+  },
+  // The files turn `runId` of `sessionId` produced (handoff-attachments.mjs),
+  // read from its live runtime when one is given, else its stored record.
+  turnArtifacts = async (sessionId, runId, runtime = null) => {
+    const stored = await loadSession(sessionId);
+    const live = typeof runtime?.readModelMessages === 'function' ? await runtime.readModelMessages(0) : null;
+    const messages = turnSlice(Array.isArray(live?.messages) ? live.messages : stored?.messages, { runId });
+    return collectTurnArtifacts(messages, { cwd: stored?.cwd, roots: sessionRoots(stored) });
+  },
   log = (line) => process.stderr.write(`mixdog task sessions: ${line}\n`),
 }) {
+  /** The report fields of turn `runId`'s files; none when it produced none. */
+  const artifactFields = async (sessionId, runId, runtime = null) => {
+    try {
+      const { files, omitted } = await turnArtifacts(sessionId, runId, runtime);
+      return files.length ? { files, ...(omitted ? { omitted } : {}) } : {};
+    } catch (error) {
+      log(`collecting the files of ${sessionId} failed: ${error?.message || error}`);
+      return {};
+    }
+  };
+  // Marks this process's watches: recovery re-attaches only an earlier one's.
+  const processToken = randomUUID();
   const service = () => {
     const value = getSessionService();
     if (!value) throw new Error('session: session service is unavailable');
@@ -85,53 +204,165 @@ export function createAgentTaskSessions({
    *  user in it) reports to the agent's home. Resolves on intake. */
   async function agentTurn(sessionId, prompt, origin, id = `atask_${randomUUID()}`, beforeReport = null) {
     const sessions = service();
+    const target = origin.target === 'session' ? { target: 'session' } : {};
+    // The watch is durable before the turn can start, so no end goes
+    // unreported across a restart; a turn whose watch could not be stored
+    // runs without a report (reportsBack false) rather than claim one.
+    let notify = false;
+    if (origin.notify !== false) {
+      try {
+        await watches.add({
+          runId: id,
+          agentId: origin.agentId,
+          homeSessionId: origin.sessionId,
+          taskSessionId: sessionId,
+          title: origin.title,
+          ...target,
+          ...(origin.textOnly ? { textOnly: true } : {}),
+          owner: processToken,
+          at: Date.now(),
+        });
+        notify = true;
+      } catch (error) {
+        log(`watch of ${sessionId} failed, sending without a report: ${error?.message || error}`);
+      }
+    }
+    const dropWatch = () =>
+      watches.remove(id).catch((error) => log(`dropping the watch of ${sessionId} failed: ${error?.message || error}`));
+    let runtime = null;
     const report = (status, text = '') =>
       Promise.resolve(beforeReport)
-        .then(() =>
+        .then(async () =>
           deliver(origin.agentId, {
             runId: `${id}_${status === 'blocked' ? 'blocked' : 'end'}`,
             taskSessionId: sessionId,
             title: origin.title,
             status,
             text,
+            ...target,
+            // A turn's end brings back the files it produced, when the agent
+            // may receive them (reportOrigin `textOnly`).
+            ...(status === 'blocked'
+              ? {}
+              : { watchId: id, ...(origin.textOnly ? {} : await artifactFields(sessionId, id, runtime)) }),
           })
         )
         .catch((error) => log(`report of ${sessionId} failed: ${error?.message || error}`));
-    const notify = origin.notify !== false;
     let unwatch = () => {};
-    if (notify) {
-      const runtime = await sessions.materializeSession(sessionId);
-      let blocked = false;
-      unwatch =
-        runtime?.subscribe?.(() => {
-          if (blocked || !runtime.getState?.()?.toolApproval) return;
-          blocked = true;
-          void report('blocked');
-        }) || unwatch;
+    let result;
+    try {
+      if (notify) {
+        runtime = await sessions.materializeSession(sessionId);
+        let blocked = false;
+        unwatch =
+          runtime?.subscribe?.(() => {
+            if (blocked || !runtime.getState?.()?.toolApproval) return;
+            blocked = true;
+            void report('blocked');
+          }) || unwatch;
+      }
+      result = await sessions.submitSession({
+        sessionId,
+        prompt,
+        options: {
+          id,
+          mode: 'prompt',
+          transcriptMeta: { sender: 'lead' },
+          ...(notify
+            ? {
+                onSettled: (detail) => {
+                  unwatch();
+                  void report(turnStatus(detail), detail?.result?.content || detail?.error || '');
+                },
+              }
+            : {}),
+        },
+      });
+    } catch (error) {
+      unwatch();
+      if (notify) await dropWatch();
+      throw error;
+    }
+    const accepted = result?.accepted === true;
+    if (!accepted) {
+      unwatch();
+      if (notify) await dropWatch();
     }
-    const result = await sessions.submitSession({
-      sessionId,
-      prompt,
-      options: {
-        id,
-        mode: 'prompt',
-        transcriptMeta: { sender: 'lead' },
-        ...(notify
-          ? {
-              onSettled: (detail) => {
-                unwatch();
-                void report(turnStatus(detail), detail?.result?.content || detail?.error || '');
-              },
+    return { accepted, reportsBack: accepted && notify };
+  }
+
+  /** Re-attach one watch a stopped daemon left: report the turn's end once
+   *  from the target's record, or watch it until it ends. */
+  async function rearm(watch) {
+    const sessionId = watch.taskSessionId;
+    const finish = async (status, text = '') =>
+      deliver(watch.agentId, {
+        runId: `${watch.runId}_end`,
+        taskSessionId: sessionId,
+        title: watch.title,
+        status,
+        text,
+        ...(watch.target === 'session' ? { target: 'session' } : {}),
+        watchId: watch.runId,
+        ...(watch.textOnly || text === GONE_TEXT || text === LOST_TEXT
+          ? {}
+          : await artifactFields(sessionId, watch.runId)),
+      });
+    if (!(await loadSession(sessionId))) return finish('cancelled', GONE_TEXT);
+    const runtime = await service().materializeSession(sessionId);
+    let done = false;
+    let checking = false;
+    let again = false;
+    let unsubscribe = () => {};
+    const check = async () => {
+      if (done) return;
+      if (checking) {
+        again = true;
+        return;
+      }
+      checking = true;
+      try {
+        do {
+          again = false;
+          const outcome = submissionOutcome((await loadSession(sessionId))?.messages, watch.runId);
+          const state = runtime?.getState?.() || {};
+          let end = outcome && outcome !== 'open' ? outcome : null;
+          if (!end && !state.busy) {
+            const queued = (state.queued || []).some((entry) => entry?.id === watch.runId);
+            if (outcome === 'open' && !queued) end = { status: 'cancelled', text: '' };
+            else if (!outcome && !queued && !(await queuedSubmissionIds(sessionId)).includes(watch.runId)) {
+              end = { status: 'cancelled', text: LOST_TEXT };
             }
-          : {}),
-      },
-    });
-    if (result?.accepted !== true) unwatch();
-    return result?.accepted === true;
+          }
+          if (end) {
+            done = true;
+            unsubscribe();
+            await finish(end.status, end.text);
+          }
+        } while (again && !done);
+      } finally {
+        checking = false;
+      }
+    };
+    const failed = (error) => log(`re-attaching ${sessionId} failed: ${error?.message || error}`);
+    unsubscribe = runtime?.subscribe?.(() => void check().catch(failed)) || unsubscribe;
+    await check();
+  }
+
+  /** Daemon start: re-attach every reporting turn an earlier process watched.
+   *  Resolves once each is reported or watched. */
+  async function recover() {
+    const pending = (await watches.list()).filter((watch) => watch?.owner !== processToken);
+    await Promise.all(
+      pending.map((watch) =>
+        rearm(watch).catch((error) => log(`re-attaching ${watch?.taskSessionId} failed: ${error?.message || error}`))
+      )
+    );
+    return pending.length;
   }
 
   /** Create the task session for `brief` and start it; returns at once. */
-  async function create(args = {}, { callerSessionId, callerAgentId, callerCwd } = {}) {
+  async function create(args = {}, { callerSessionId, callerAgentId, callerCwd, attachmentParts = [] } = {}) {
     if (!callerAgentId) throw new Error('session: create is only for an agent conversation');
     const brief = typeof args.brief === 'string' ? args.brief.trim() : '';
     if (!brief) throw new Error('session: brief is required for action=create');
@@ -145,7 +376,13 @@ export function createAgentTaskSessions({
       title,
       notify: args.notify !== false,
     };
-    const route = clean(args.model) ? await modelRoute(clean(args.model)) : {};
+    // A task session runs in coding mode under Lead: an explicit model wins,
+    // else the Lead route, else the last-used model. Never a model-less
+    // session — the composer would show no model and its first turn would fail.
+    const route = clean(args.model)
+      ? await modelRoute(clean(args.model))
+      : (await leadRoute()) || (await lastUsedRoute(service()));
+    if (!route) throw new Error('session: no model to start the task session on. Choose a Lead model first.');
     const sessions = service();
     const created = await sessions.createSession({
       ...route,
@@ -175,9 +412,11 @@ export function createAgentTaskSessions({
     const ready = new Promise((resolveReady) => {
       started = resolveReady;
     });
-    const accepted = await agentTurn(sessionId, brief, taskOrigin, requestId, ready);
+    // The brief carries the files the agent forwarded (workspace-tools.mjs).
+    const prompt = handoffContent(brief, attachmentParts);
+    const { accepted, reportsBack } = await agentTurn(sessionId, prompt, taskOrigin, requestId, ready);
     if (!accepted) throw new Error(`session: task session ${sessionId} did not accept the brief`);
-    if (taskOrigin.notify) {
+    if (reportsBack) {
       await deliver(callerAgentId, {
         runId: `${requestId}_started`,
         taskSessionId: sessionId,
@@ -186,15 +425,36 @@ export function createAgentTaskSessions({
       }).catch((error) => log(`start line of ${sessionId} failed: ${error?.message || error}`));
     }
     started();
-    return { session_id: sessionId, title, project: where.project?.path ?? null };
+    return {
+      session_id: sessionId,
+      title,
+      project: where.project?.path ?? null,
+      ...(taskOrigin.notify && !reportsBack ? { reportsBack: false } : {}),
+    };
   }
 
-  /** The origin of a task session, when `agentId` created it. */
-  async function originFor(sessionId, agentId) {
+  /** The origin a `send` of agent `agentId` (from its home `callerSessionId`)
+   *  reports to: the stored one of a task session it created, else one for
+   *  this send only — never stored on the target, whose own origin and owner
+   *  stay as they are. Null for a caller that is no agent conversation. */
+  async function reportOrigin(sessionId, agentId, callerSessionId) {
     if (!agentId) return null;
-    const origin = (await loadSession(sessionId))?.taskOrigin;
-    return origin?.agentId === agentId ? origin : null;
+    const target = await loadSession(sessionId);
+    const origin = target?.taskOrigin;
+    if (origin?.agentId === agentId) return origin;
+    const title = (clean(target?.title) || sessionId).slice(0, TITLE_LIMIT);
+    // Files come back only from sessions the agent created (above) or its own
+    // room member threads; any other session reports its text alone.
+    const own = roomMemberOfSession(sessionId)?.agentId === agentId;
+    return {
+      agentId,
+      sessionId: callerSessionId,
+      title,
+      notify: true,
+      target: 'session',
+      ...(own ? {} : { textOnly: true }),
+    };
   }
 
-  return { create, originFor, send: (sessionId, prompt, origin) => agentTurn(sessionId, prompt, origin) };
+  return { create, reportOrigin, recover, send: (sessionId, prompt, origin) => agentTurn(sessionId, prompt, origin) };
 }

package/src/session-runtime/boot/apis.mjs

@@ -67,6 +67,7 @@ import { createConversationImportApi } from '../conversation-import/service.mjs'
 import { importError } from '../conversation-import/discovery.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
+import { registerBotRouteStore } from '../../runtime/shared/agent-store.mjs';
 import {
   dataDirOf,
   resolveRoute,
@@ -124,7 +125,16 @@ export function wireApis(boot) {
     } catch (error) {
       bootProfile('connector-policy:migrate-failed', { error: error?.message || String(error) });
     }
+    // Bots get their own store (bots/) once, before any catalog read; a
+    // failed split leaves agents/ read as before (bot-split-migration.mjs).
+    try {
+      boot.workflowAgentsApi.migrateBotStore();
+    } catch (error) {
+      bootProfile('bot-split:migrate-failed', { error: error?.message || String(error) });
+    }
   }
+  // Route reads ask a store bot's own folder first (agent-store.mjs).
+  registerBotRouteStore(() => dataDirOf(boot.cfgMod));
   boot.workspaceApi = workspaceApiFor(boot);
   boot.sessionTurnApi = sessionTurnApiFor(boot);
   const getFacadeSessionId = () => boot.rt.session?.id || boot.rt.reservedSessionId || null;
@@ -538,6 +548,8 @@ function modelRouteApiFor(boot) {
     adoptConfig: boot.adoptConfig,
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
     ensureFullConfig: boot.ensureFullConfig,
+    reloadFullConfig: boot.reloadFullConfig,
+    confirmLeadFill: boot.confirmLeadFill,
     awaitKeychainPrewarm: boot.awaitKeychainPrewarm,
     ensureProvidersReady: boot.ensureProvidersReady,
     persistLeadRoute: boot.persistLeadRoute,
@@ -567,6 +579,7 @@ function workflowAgentsApiFor(boot) {
     lookupModelMeta: boot.lookupModelMeta,
     adoptConfig: boot.adoptConfig,
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
+    reloadFullConfig: boot.reloadFullConfig,
     ensureProvidersReady: boot.ensureProvidersReady,
     displayConfig: boot.displayConfig,
     mcpStatus: () => boot.mcpStatus(),

package/src/session-runtime/boot/providers.mjs

@@ -11,7 +11,10 @@ import { LOCAL_PROVIDER_ID, configureLocalProviderIdleTtl } from '../../runtime/
 import { resolve } from 'node:path';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { LAZY_SECRET_PROVIDERS } from '../../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
-import { ensureProviderEnabled, normalizeSystemShellConfig } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import {
+  ensureProviderEnabled,
+  normalizeSystemShellConfig,
+} from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import {
   workflowPresetId,
   normalizeWebSearchProviderId,
@@ -33,7 +36,7 @@ import { createProviderModels } from '../provider-models.mjs';
 import { createProviderUsage } from '../provider-usage.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
-import { outputStyleStatus, webSearchCapableFor } from './shared.mjs';
+import { outputStyleStatus, resolveRoute, webSearchCapableFor } from './shared.mjs';
 
 export function wireProviders(boot) {
   wireConfigLifecycle(boot);
@@ -63,6 +66,10 @@ function wireConfigLifecycle(boot) {
       rt.configHasSecrets = next;
     },
     getRoute: () => rt.route,
+    setRouteState: (next) => {
+      rt.route = next;
+    },
+    resolveRoute,
     cfgMod,
     sharedCfgMod,
     setConfiguredShell,
@@ -82,6 +89,7 @@ function wireConfigLifecycle(boot) {
     seedOutputStyleStatusCache,
     adoptConfig,
     saveConfigAndAdopt,
+    confirmLeadFill,
     scheduleSkillsSave,
     flushSkillsSave,
     scheduleOutputStyleSave,
@@ -98,6 +106,7 @@ function wireConfigLifecycle(boot) {
     seedOutputStyleStatusCache,
     adoptConfig,
     saveConfigAndAdopt,
+    confirmLeadFill,
     scheduleSkillsSave,
     flushSkillsSave,
     scheduleOutputStyleSave,
@@ -106,13 +115,14 @@ function wireConfigLifecycle(boot) {
     ensureFullConfig,
     displayConfig,
     ensureConfigForRouteProvider,
-    persistLeadRoute: (routeLike) => {
+    persistLeadRoute: (routeLike, { onlyIfAbsent = false } = {}) => {
       const leadRoute = normalizeWorkflowRoute(routeLike);
       if (!leadRoute) return null;
       const nextConfig = { ...(rt.config || {}) };
       nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, 'lead', leadRoute);
       nextConfig.default = workflowPresetId('lead');
-      saveConfigAndAdopt(nextConfig);
+      // A conditional fill reaches the file only while no Lead route is stored.
+      saveConfigAndAdopt(nextConfig, { leadFill: onlyIfAbsent });
       return leadRoute;
     },
   });

package/src/session-runtime/config-lifecycle.mjs

@@ -79,6 +79,9 @@ export function createConfigLifecycle({
   getConfigHasSecrets,
   setConfigHasSecrets,
   getRoute,
+  // Main route sync on reload (both optional: a lifecycle without them never syncs)
+  setRouteState,
+  resolveRoute,
   // shared modules / helpers
   cfgMod,
   sharedCfgMod,
@@ -121,16 +124,42 @@ export function createConfigLifecycle({
   // separate from adoptConfig: model tuning is adopted before its route save.
   let configSaveBaseline = structuredClone(getConfig());
 
-  function saveConfigAndAdopt(nextConfig, { hasSecrets = getConfigHasSecrets() } = {}) {
+  // The Lead route lives in these two stored keys; a conditional fill writes
+  // them only while `default` is still unset on disk, judged under the config
+  // file lock when the patch is applied (config-patch.mjs `unlessSet`).
+  const LEAD_FILL_KEYS = new Set(['default', 'presets']);
+
+  function saveConfigAndAdopt(nextConfig, { hasSecrets = getConfigHasSecrets(), leadFill = false } = {}) {
     // In-memory adopt is synchronous and first so callers that read back the
     // value immediately (e.g. setProfile -> getProfile) see the new state.
     const adopted = adoptConfig(nextConfig, { hasSecrets });
-    const changes = cfgMod.createConfigPatch(configSaveBaseline, adopted);
+    const changes = cfgMod
+      .createConfigPatch(configSaveBaseline, adopted)
+      .map((change) =>
+        leadFill && LEAD_FILL_KEYS.has(change.path[0]) ? { ...change, unlessSet: ['default'] } : change
+      );
     configSaveBaseline = structuredClone(adopted);
     if (changes.length) writers.queueConfigChanges([...changes, ...seedChanges(adopted, changes)]);
     return adopted;
   }
 
+  const sameModel = (a, b) => clean(a?.provider) === clean(b?.provider) && clean(a?.model) === clean(b?.model);
+
+  /** After a conditional Lead fill adopted `filled`: persist it now and, when
+   *  the file already held another Lead route (written by another process after
+   *  the fill's re-read, so the patch skipped it), adopt that one instead.
+   *  Answers whether the runtime route was replaced. A route the user has moved
+   *  off `filled` meanwhile stays. */
+  async function confirmLeadFill(filled) {
+    await writers.flushConfigSaveAsync();
+    reloadFullConfig();
+    if (!setRouteState || !resolveRoute || !sameModel(getRoute(), filled)) return false;
+    const winner = resolveRoute(getConfig(), {});
+    if (!clean(winner?.model) || sameModel(winner, filled)) return false;
+    setRouteState(winner);
+    return true;
+  }
+
   // A fresh profile's install markers (an empty `builtins`) equal the
   // defaults, so no diff ever carries them — yet on disk their absence reads
   // as a grandfathered profile. The first write seeds them where the stored
@@ -177,9 +206,20 @@ export function createConfigLifecycle({
     }
     const adopted = adoptConfig(next, { hasSecrets: true });
     configSaveBaseline = structuredClone(adopted);
+    syncEmptyMainRoute(adopted);
     return adopted;
   }
 
+  // A Main route the runtime still has no model for takes the Lead route a
+  // reload brings in (edited on disk or by another process), so a conditional
+  // backfill sees it and never overwrites it. A live route that has a model is
+  // the user's selection and stays.
+  function syncEmptyMainRoute(config) {
+    if (!setRouteState || !resolveRoute || clean(getRoute()?.model)) return;
+    const resolved = resolveRoute(config, {});
+    if (clean(resolved?.model)) setRouteState(resolved);
+  }
+
   function ensureFullConfig() {
     if (getConfigHasSecrets()) return getConfig();
     return reloadFullConfig();
@@ -211,6 +251,7 @@ export function createConfigLifecycle({
     // adopt / save
     adoptConfig,
     saveConfigAndAdopt,
+    confirmLeadFill,
     // Skills publication also drains older config edits first.
     flushSkillsSave: writers.flushConfigSaveAsync,
     scheduleSkillsSave,