mixdog 1.3.5 → 1.4.0

package/src/session-runtime/resource-mcp-oauth-api.mjs

@@ -0,0 +1,217 @@
+// MCP OAuth sign-in and sign-out of a configured server or of one account of a
+// multi-account connector server: the interactive login flows
+// (mcp-oauth-login.mjs), the transactional account switch, and the
+// credential-free auth probe.
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { createMcpOAuthLogins } from './mcp-oauth-login.mjs';
+import { connectorAccountServers, connectorAccountsOf } from '../runtime/shared/connector-catalog.mjs';
+import { forgetConnectorAccountHealth } from '../runtime/connectors/connector-accounts-mcp.mjs';
+import { accountTarget } from './resource-mcp-servers.mjs';
+
+export function createMcpOAuthApi({
+  sync,
+  mcpStatus,
+  connectConfiguredMcp,
+  clearMcpServerOAuth,
+  reloadFullConfig,
+  awaitKeychainPrewarm,
+  resolveMcpCatalog,
+  cancelMcpLogin,
+  completeMcpLogin,
+  getMcpServerOAuthState,
+  probeMcpServerAuth,
+  startMcpServerOAuthSwitch,
+  commitMcpServerOAuthSwitch,
+}) {
+  const reconnectOne = async (name) => {
+    const status = await connectConfiguredMcp({ only: name, enabled: true });
+    const row = status?.servers?.find((server) => server.name === name);
+    return { connected: row?.connected === true, error: row?.error || null };
+  };
+  // Explicit OAuth sign-in: the one interactive MCP connect. On success the
+  // other runtimes reconnect the server non-interactively with the new tokens.
+  const oauthLogins = createMcpOAuthLogins({
+    async connect(name, openBrowser) {
+      const status = await connectConfiguredMcp({ only: name, enabled: true, login: { openBrowser } });
+      const row = status?.servers?.find((server) => server.name === name);
+      return { connected: row?.connected === true, error: row?.error || null };
+    },
+    cancel: (name) => cancelMcpLogin(name),
+    completeCallback: completeMcpLogin,
+    // 계정 바꾸기, transactionally: the working connection stays until the new
+    // sign-in succeeded and connects; a cancel or failure changes nothing, and
+    // a new sign-in that cannot connect is rolled back.
+    // An account of a multi-account connector signs in the same way, any
+    // mode: beside its stored sign-in (if any), then its server reconnects.
+    async switchAccount(name, launch, attempt) {
+      const servers = resolveMcpCatalog().servers;
+      const target = accountTarget(servers, name);
+      const cfg = target ? target.accountCfg : servers[name];
+      const serverName = target ? target.serverName : name;
+      // 연결 / 다시 인증 of a signed-in account: its stored sign-in (refreshed
+      // as needed) is tried first; the browser opens only when that fails.
+      if (target && launch.accountMode !== 'switch' && getMcpServerOAuthState(cfg)?.signedIn === true) {
+        const repaired = await reconnectOne(serverName);
+        if (repaired.connected && !connectorAccountError(name)) return repaired;
+      }
+      const switching = startMcpServerOAuthSwitch(cfg, launch, name);
+      attempt.abort = () => switching.cancel();
+      attempt.answer = (callbackUrl) => switching.answer(callbackUrl);
+      const signIn = await switching.done;
+      // The same account twice would leave `account` ambiguous.
+      const address = String(signIn?.identity?.account || '').toLowerCase();
+      if (target && address) {
+        const twin = connectorAccountServers(target.cfg).find(
+          (other) =>
+            other.name !== name && String(getMcpServerOAuthState(other)?.account || '').toLowerCase() === address
+        );
+        if (twin) return { connected: false, error: `${signIn.identity.account} is already connected` };
+      }
+      const rollback = await commitMcpServerOAuthSwitch(cfg, signIn);
+      const outcome = await reconnectOne(serverName);
+      const accountError = target ? connectorAccountError(name) : '';
+      if (outcome.connected && !accountError) return outcome;
+      await rollback();
+      await reconnectOne(serverName);
+      return { connected: false, error: accountError || outcome.error || 'The new sign-in could not connect' };
+    },
+    onComplete: (name) =>
+      sync.announce('mcp', {
+        detail: {
+          mcpChanges: [{ name: accountTarget(resolveMcpCatalog().servers, name)?.serverName || name, enabled: true }],
+        },
+      }),
+  });
+  /** The effective config of a server that signs in with MCP OAuth (HTTP/SSE
+   *  without configured authentication). */
+  const oauthServerConfig = async (name) => {
+    const serverName = clean(name);
+    if (!serverName) throw new Error('MCP server name is required');
+    await awaitKeychainPrewarm();
+    reloadFullConfig();
+    const cfg = resolveMcpCatalog().servers[serverName];
+    if (!cfg) throw new Error(`MCP server not configured: ${serverName}`);
+    if (!getMcpServerOAuthState(cfg)) throw new Error(`MCP server "${serverName}" does not use OAuth sign-in`);
+    return { serverName, cfg };
+  };
+
+  /** The sign-in account `name` addresses on a multi-account connector
+   *  server — an account's name, or the server's name when it has exactly one
+   *  sign-in account (`every`: all of them, for a sign-out) — as
+   *  `{ serverName, cfg, account, accountCfg, signOut: [accountCfg…] }`;
+   *  null for any other server. */
+  const signInAccount = async (name, { every = false } = {}) => {
+    const wanted = clean(name);
+    if (!wanted) throw new Error('MCP server name is required');
+    await awaitKeychainPrewarm();
+    reloadFullConfig();
+    const servers = resolveMcpCatalog().servers;
+    const target = accountTarget(servers, wanted);
+    if (target) {
+      if (!getMcpServerOAuthState(target.accountCfg)) {
+        throw new Error(`MCP server "${wanted}" does not use OAuth sign-in`);
+      }
+      return { ...target, signOut: [target.accountCfg] };
+    }
+    const cfg = servers[wanted];
+    if (!connectorAccountsOf(cfg).length) return null;
+    const signIns = connectorAccountServers(cfg).filter((accountCfg) => getMcpServerOAuthState(accountCfg));
+    if (every && signIns.length) return { serverName: wanted, cfg, account: null, accountCfg: null, signOut: signIns };
+    if (signIns.length === 1) {
+      const account = connectorAccountsOf(cfg).find((entry) => entry.name === signIns[0].name);
+      return { serverName: wanted, cfg, account, accountCfg: signIns[0], signOut: signIns };
+    }
+    throw new Error(
+      signIns.length
+        ? `MCP server "${wanted}" has several accounts; name the account to sign in`
+        : `MCP server "${wanted}" does not use OAuth sign-in`
+    );
+  };
+
+  /** What account `name` of a multi-account connector currently fails with ('' when fine). */
+  function connectorAccountError(name) {
+    for (const row of mcpStatus()?.servers || []) {
+      const account = (Array.isArray(row.accounts) ? row.accounts : []).find((entry) => entry.name === name);
+      if (account) return account.error || (account.authRequired ? 'Sign-in required' : '');
+    }
+    return '';
+  }
+
+  return {
+    /** `{ flowId, state: 'pending', url }` once the browser login starts
+     *  (`options.openBrowser === false` leaves opening `url` to the caller), or
+     *  `{ flowId, state: 'complete' }` when stored credentials sufficed. */
+    async beginMcpOAuthLogin(name, options = {}) {
+      const account = await signInAccount(name);
+      if (account) {
+        if (account.cfg.enabled === false) throw new Error(`MCP server is disabled: ${account.serverName}`);
+        // Beside the stored sign-in, whatever the mode: the account's server keeps running meanwhile.
+        return oauthLogins.begin(account.account.name, { ...(options || {}), beside: true });
+      }
+      const { beside: _beside, ...ownOptions } = options || {};
+      options = ownOptions;
+      const { serverName, cfg } = await oauthServerConfig(name);
+      if (cfg.enabled === false) throw new Error(`MCP server is disabled: ${serverName}`);
+      // `mode`: `connect` (a normal authorization), `reauth` (repair the same
+      // connection; a refresh is tried first) or `switch` (계정 바꾸기).
+      if (options?.mode === 'switch' && !getMcpServerOAuthState(cfg)?.signedIn) {
+        throw new Error(`MCP server "${serverName}" is not signed in`);
+      }
+      return oauthLogins.begin(serverName, options);
+    },
+    /** `{ flowId, state: 'pending' | 'complete' | 'failed' | 'cancelled',
+     *  step?, error?, reason? }`; with `{ since, waitMs }` it resolves on the
+     *  flow's next change (mcp-oauth-login.mjs). */
+    getMcpOAuthLoginStatus(flowId, options) {
+      return oauthLogins.status(flowId, options);
+    },
+    cancelMcpOAuthLogin(flowId) {
+      return oauthLogins.cancel(flowId);
+    },
+    /** Remote / headless sign-in: complete the pending flow with the redirect
+     *  URL pasted from the browser. `{ flowId, state: 'complete' | 'failed',
+     *  error? }`; an invalid paste throws a fixed message and stays pending. */
+    completeMcpOAuthLogin(flowId, callbackUrl) {
+      return oauthLogins.complete(flowId, callbackUrl);
+    },
+    /** Forget the server's stored OAuth credentials (shared by every server
+     *  with the same exact URL) and reconnect without a login, here and on
+     *  peers, so it reports sign-in required. */
+    async signOutMcpServer(name) {
+      const account = await signInAccount(name, { every: true });
+      if (account) {
+        const accountName = account.account?.name || clean(name);
+        return oauthLogins.cancelServer(accountName, async () => {
+          let revoked = true;
+          for (const accountCfg of account.signOut) {
+            forgetConnectorAccountHealth(accountCfg.name);
+            revoked = (await clearMcpServerOAuth(accountCfg, { revoke: true }))?.revoked === true && revoked;
+          }
+          const status = await sync.reconnectMcpAndAnnounce({
+            only: account.serverName,
+            enabled: account.cfg.enabled !== false,
+          });
+          return { ...status, revoked };
+        });
+      }
+      const { serverName, cfg } = await oauthServerConfig(name);
+      // A begin issued meanwhile waits until the credentials are gone.
+      return oauthLogins.cancelServer(serverName, async () => {
+        const { revoked = false } = (await clearMcpServerOAuth(cfg, { revoke: true })) || {};
+        const status = await sync.reconnectMcpAndAnnounce({ only: serverName, enabled: cfg.enabled !== false });
+        return { ...status, revoked };
+      });
+    },
+    /** `{ auth: 'oauth' | 'none' | 'configured' | 'unreachable', error? }` for an
+     *  HTTP/SSE config, without credentials or a browser. */
+    probeMcpServerAuth(cfg) {
+      if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) throw new TypeError('MCP server config is required');
+      const probe = {};
+      for (const key of ['type', 'url', 'headers', 'bearer_token_env_var', 'env_http_headers']) {
+        if (cfg[key] !== undefined) probe[key] = cfg[key];
+      }
+      if (probe.type !== 'http' && probe.type !== 'sse') throw new TypeError("type must be 'http' or 'sse'");
+      return probeMcpServerAuth(probe);
+    },
+  };
+}

package/src/session-runtime/resource-mcp-secrets.mjs

@@ -0,0 +1,82 @@
+// The keychain side of MCP server edits: storing a server's OAuth client
+// secret or Gmail app password, and releasing a removed server's or account's
+// sign-in once no other configured server shares it.
+import {
+  gmailAppPasswordAccount,
+  gmailAppPasswordValue,
+  connectorAccountServers,
+} from '../runtime/shared/connector-catalog.mjs';
+import { forgetConnectorAccountHealth } from '../runtime/connectors/connector-accounts-mcp.mjs';
+import { oauthUrlOf } from './resource-mcp-servers.mjs';
+
+/** Every config `servers` connects with, a multi-account server's accounts
+ *  as the one-account configs they are. */
+const expandedConfigs = (servers) =>
+  Object.values(servers || {}).flatMap((cfg) => {
+    const accounts = connectorAccountServers(cfg);
+    return accounts.length ? accounts : [cfg];
+  });
+
+export function createMcpServerSecrets({
+  gmailAppPassword,
+  saveOAuthClientSecret,
+  clearMcpServerOAuth,
+  resolveConfiguredMcpCatalog,
+}) {
+  // The user's OAuth client secret (custom connector → 고급 설정 → 비밀값)
+  // goes to the keychain only; clearing the client id forgets it.
+  const storeOAuthClientSecret = async (input, cfg, previous = {}) => {
+    if (!cfg?.url) return;
+    const secret = typeof input.oauthClientSecret === 'string' ? input.oauthClientSecret.trim() : '';
+    if (cfg.oauthClientId && secret) await saveOAuthClientSecret(cfg.url, secret);
+    else if (!cfg.oauthClientId && previous.oauthClientId) await saveOAuthClientSecret(previous.url || cfg.url, '');
+  };
+  // Gmail with an app password (connector-catalog.mjs GMAIL_APP_PASSWORD): the
+  // password is checked with Gmail before anything is saved and goes to the
+  // keychain only. A new connection needs one; an edit without one keeps it.
+  const storeGmailAppPassword = async (input, cfg, required) => {
+    const account = gmailAppPasswordAccount(cfg);
+    if (!account) return;
+    const password = gmailAppPasswordValue(input.appPassword);
+    if (password) await gmailAppPassword.save(account, password);
+    else if (required || input.appPassword !== undefined) {
+      throw new Error('GMAIL_APP_PASSWORD_FORMAT: An app password has 16 characters.');
+    }
+  };
+  // A server's OAuth tokens and client registration go with it, unless another
+  // configured server (plugin or disabled ones included, even with MCP
+  // disabled for this runtime) still uses them through the same exact URL.
+  // `signIn` tells the caller what happened to the sign-in: `removed` (local
+  // secrets deleted, `revoked` when the provider confirmed the revocation
+  // too), `shared` (another server still uses it), or none (null).
+  const releaseOAuth = async (cfg) => {
+    const url = oauthUrlOf(cfg);
+    if (!url) return null;
+    if (expandedConfigs(resolveConfiguredMcpCatalog().servers).some((other) => oauthUrlOf(other) === url)) {
+      return { signIn: 'shared', revoked: false };
+    }
+    const { revoked = false } = (await clearMcpServerOAuth(cfg, { revoke: true })) || {};
+    return { signIn: 'removed', revoked };
+  };
+  // An app password is deleted once no configured server uses its account.
+  const forgetUnusedGmailAppPassword = async (account) => {
+    if (!account) return false;
+    const servers = expandedConfigs(resolveConfiguredMcpCatalog().servers);
+    if (servers.some((cfg) => gmailAppPasswordAccount(cfg) === account)) return false;
+    await gmailAppPassword.forget(account);
+    return true;
+  };
+  // A removed account keeps no sign-in another configured server or account
+  // does not share: `{ signIn, revoked }` as removeMcpServer reports it.
+  const releaseAccount = async (accountCfg) => {
+    forgetConnectorAccountHealth(accountCfg.name);
+    const address = gmailAppPasswordAccount(accountCfg);
+    if (address) {
+      const forgotten = await forgetUnusedGmailAppPassword(address);
+      return { signIn: forgotten ? 'removed' : 'shared', revoked: false };
+    }
+    return releaseOAuth(accountCfg);
+  };
+
+  return { storeOAuthClientSecret, storeGmailAppPassword, releaseOAuth, forgetUnusedGmailAppPassword, releaseAccount };
+}

package/src/session-runtime/resource-mcp-servers.mjs

@@ -0,0 +1,78 @@
+// Pure reads of an `mcpServers` map shared by the MCP server API units
+// (resource-mcp-api.mjs): OAuth URLs, multi-account connector account lookup,
+// name refusals and the merge of a partial server edit.
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { MCP_TIMEOUT_FIELD_GROUPS } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { resolveMcpOAuthUrl } from '../runtime/agent/orchestrator/mcp/client-config.mjs';
+import {
+  connectorAccountServer,
+  connectorAccountsOf,
+  connectorById,
+  connectorOfServer,
+} from '../runtime/shared/connector-catalog.mjs';
+
+/** The URL a server's OAuth credentials are stored under, or null. */
+export function oauthUrlOf(cfg) {
+  try {
+    return resolveMcpOAuthUrl(cfg);
+  } catch {
+    // No valid remote URL: such a server never logged in.
+    return null;
+  }
+}
+
+/** The `mcpServers` map of a config as a fresh object (never the live one). */
+export function mcpServersOf(config) {
+  return config.mcpServers && typeof config.mcpServers === 'object' ? { ...config.mcpServers } : {};
+}
+
+/** The multi-account connector account `name` names in `servers`:
+ *  `{ serverName, cfg, account, accountCfg }`, or null. */
+export function accountTarget(servers, name) {
+  for (const [serverName, cfg] of Object.entries(servers || {})) {
+    const account = connectorAccountsOf(cfg).find((entry) => entry.name === name);
+    if (account) return { serverName, cfg, account, accountCfg: connectorAccountServer(cfg, account) };
+  }
+  return null;
+}
+
+/** The refusal of a new server name that is taken. A name a connector account
+ *  holds is an account to the user (never a server), so it says so. */
+export function nameTakenError(servers, name) {
+  const holder = accountTarget(servers, name);
+  const connector = holder && connectorById(connectorOfServer(holder.cfg));
+  return new Error(
+    connector
+      ? `The name "${name}" is used by a ${connector.name} account. Choose another name.`
+      : `MCP server already exists: ${name}`
+  );
+}
+
+const transportType = (type) => (type === 'streamable-http' ? 'http' : type);
+
+/** UI editors send complete transports; setup may send a partial patch. Merge
+ *  the patch over the existing entry, keeping omitted fields (including
+ *  credentials) unless the transport itself changed. */
+export function mergedServerInput(input, existing, originalName) {
+  const transportChanged =
+    (input.type && transportType(input.type) !== transportType(existing.type || (existing.url ? 'http' : 'stdio'))) ||
+    (input.command && existing.url) ||
+    (input.url && !existing.url);
+  const maps = {};
+  if (!transportChanged) {
+    for (const key of ['env', 'headers', 'env_http_headers']) {
+      if (Object.hasOwn(input, key)) maps[key] = { ...(existing[key] || {}), ...input[key] };
+    }
+  }
+  // Existing timeouts are kept by mergeMcpServerConfig; the normalizer must only
+  // see (and validate) newly supplied ones, so a stored 0/'off' never blocks
+  // an unrelated save.
+  const { ...base } = transportChanged ? {} : existing;
+  for (const field of MCP_TIMEOUT_FIELD_GROUPS.flat()) delete base[field];
+  return {
+    ...base,
+    ...input,
+    ...maps,
+    name: clean(input.name) || originalName,
+  };
+}

package/src/session-runtime/resource-mcp-store.mjs

@@ -0,0 +1,49 @@
+// The user's `mcpServers` as the MCP server API reads and writes it: every
+// read already merged (one server per multi-account connector) and with
+// adoptable plugin copies adopted; every write persisted with collision names
+// pinned. Also the free-name and plugin-ownership checks over that registry.
+import { withAdoptedCopies, withPinnedCollisionNames } from './mcp-glue/plugin-servers.mjs';
+import { connectorAccountsOf, mergeConnectorAccountServers } from '../runtime/shared/connector-catalog.mjs';
+import { mcpServersOf } from './resource-mcp-servers.mjs';
+
+function pluginOwnedError(name, owner) {
+  return new Error(
+    `MCP server "${name}" is provided by plugin "${owner.id}" (server "${owner.key}"); ` +
+      'enable or disable it with set_mcp_enabled, or manage the plugin instead'
+  );
+}
+
+export function createMcpServerStore({ getConfig, saveConfigAndAdopt, resolveMcpCatalog, pluginMcpServer }) {
+  /** The config with any adoptable plugin server copies already adopted, so
+   *  every write also persists the adoption and never re-adds a copy. */
+  const adoptedConfig = () => withAdoptedCopies(getConfig(), resolveMcpCatalog().adoption);
+
+  /** Persist a new `mcpServers` map; project overrides never survive a global
+   *  edit. A plugin server pushed off its name by the edit keeps the collision
+   *  name it gets, so it does not flip again later. */
+  const saveServers = (servers) => {
+    const nextConfig = { ...adoptedConfig() };
+    delete nextConfig.mcpProjectOverrides;
+    saveConfigAndAdopt({ ...nextConfig, mcpServers: servers });
+    const saved = getConfig();
+    const pinned = withPinnedCollisionNames(saved, resolveMcpCatalog());
+    if (pinned !== saved) saveConfigAndAdopt(pinned);
+  };
+  // Every write starts from the merged form: one server per multi-account connector.
+  const userServers = () => mergeConnectorAccountServers(mcpServersOf(adoptedConfig())).servers;
+  /** A name no server, plugin server or account has yet: `base`, else `base-2`… */
+  const freeName = (servers, base) => {
+    const taken = new Set(
+      Object.entries(servers).flatMap(([name, cfg]) => [name, ...connectorAccountsOf(cfg).map((a) => a.name)])
+    );
+    const free = (name) => !taken.has(name) && !pluginMcpServer(name);
+    if (free(base)) return base;
+    for (let n = 2; ; n += 1) if (free(`${base}-${n}`)) return `${base}-${n}`;
+  };
+  const refusePluginServer = (name) => {
+    const owned = name ? pluginMcpServer(name) : null;
+    if (owned) throw pluginOwnedError(name, owned.owner);
+  };
+
+  return { adoptedConfig, saveServers, userServers, freeName, refusePluginServer };
+}

package/src/session-runtime/routine-owner.mjs

@@ -6,6 +6,7 @@
  * and a new routine cannot name it.
  */
 import { MIXY_AGENT_ID } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import { mixyExists } from '../runtime/shared/mixy-presence.mjs';
 import { scheduleOwnerAgentId } from './agent-home-delivery.mjs';
 
 /** `ownerProblem` codes and the error each one raises. */
@@ -15,7 +16,7 @@ export const ROUTINE_OWNER_PROBLEMS = Object.freeze({
 });
 
 let editor = null;
-async function defaultProbe() {
+async function editorApi() {
   if (!editor) {
     const [{ getPluginData }, { createAgentEditorApi }] = await Promise.all([
       import('../runtime/agent/orchestrator/config.mjs'),
@@ -23,21 +24,51 @@ async function defaultProbe() {
     ]);
     editor = createAgentEditorApi({ cfgMod: { getPluginData } });
   }
+  return editor;
+}
+
+/** Whether a stored schedule or webhook belongs to Mixy (ownerless rows do).
+ *  Without a PostgreSQL cluster none exists, and none is started for this. */
+export async function mixyOwnsRoutines() {
+  const [{ pgClusterExists }, { resolvePluginData }] = await Promise.all([
+    import('../runtime/memory/lib/pg/adapter.mjs'),
+    import('../runtime/shared/plugin-paths.mjs'),
+  ]);
+  if (!pgClusterExists(resolvePluginData())) return false;
+  const [{ listSchedules }, { listEndpoints }] = await Promise.all([
+    import('../runtime/channels/lib/schedules-db.mjs'),
+    import('../runtime/channels/lib/webhooks-db.mjs'),
+  ]);
+  const [schedules, webhooks] = await Promise.all([listSchedules(), listEndpoints()]);
+  return [...schedules, ...webhooks].some((row) => scheduleOwnerAgentId(row) === MIXY_AGENT_ID);
+}
+
+/** Whether Mixy exists (mixy-presence.mjs, the one rule), from `status`
+ *  (getLeadStatus) or a fresh read of it. `ownsRoutine`: the caller holds a
+ *  stored routine of hers, so her routines need no read. Rejects when they
+ *  cannot be read and nothing else decides. */
+export async function readMixyExists(status = null, { ownsRoutine = false } = {}) {
+  return mixyExists(status ?? (await editorApi()).getLeadStatus(), ownsRoutine ? async () => true : mixyOwnsRoutines);
+}
+
+async function defaultProbe() {
+  const api = await editorApi();
   return {
-    // An undecided profile (null) counts as having Mixy: nobody is blocked by
-    // a flag the host has not written yet.
-    mixyExists: () => editor.getLeadStatus().created !== false,
-    presence: (agentId) => editor.agentDefinitionPresence([agentId])[agentId],
+    mixyExists: (ownsRoutine) => readMixyExists(null, { ownsRoutine }),
+    presence: (agentId) => api.agentDefinitionPresence([agentId])[agentId],
   };
 }
 
 /** Why `ownerAgentId` (none = Mixy) cannot own or run a routine: a
- *  ROUTINE_OWNER_PROBLEMS code, '' when it can. Only a proven deletion
- *  counts for a bot; a read fault never pauses anything. */
-export async function routineOwnerProblem(ownerAgentId, probe = null) {
+ *  ROUTINE_OWNER_PROBLEMS code, '' when it can. `stored`: asked for a stored
+ *  routine of that owner (a run, a list row). A routine Mixy owns is itself
+ *  evidence of her, so only `created: false` pauses one; a new one needs her
+ *  to exist. Only a proven deletion counts for a bot; a read fault never
+ *  pauses anything (callers take a rejection as no problem). */
+export async function routineOwnerProblem(ownerAgentId, probe = null, { stored = false } = {}) {
   const owner = scheduleOwnerAgentId({ ownerAgentId });
   const check = probe || (await defaultProbe());
-  if (owner === MIXY_AGENT_ID) return check.mixyExists() ? '' : 'no-mixy';
+  if (owner === MIXY_AGENT_ID) return (await check.mixyExists(stored)) ? '' : 'no-mixy';
   return check.presence(owner) === 'deleted' ? 'owner-deleted' : '';
 }
 

package/src/session-runtime/services/agent-tool/close-flow.mjs

@@ -92,6 +92,9 @@ export function createCloseFlow({ mgr, registry, views }) {
       for (const descendantSessionId of descendantSessionIds) {
         registry.removeWorkerRow({ sessionId: descendantSessionId });
       }
+      // The sessions stay open (a send reuses them), so a later scan, even
+      // after a restart, would list them again: remember the owner closed them.
+      registry.markReleased([sessionId, ...descendantSessionIds]);
     }
     return { closed: ok, tag, sessionId, task_id: task?.taskId || null };
   }

package/src/session-runtime/services/agent-tool/spawn-preset.mjs

@@ -31,6 +31,9 @@ export function resolveAgentSpawnPreset(config, args = {}) {
   const candidates = !clean(args.preset) ? configuredAgentRouteCandidates(config, agentName) : [];
   const agentRoute = candidates.map((candidate) => normalizeAgentRoute(candidate)).find(Boolean) || null;
   const storedFallbacks = candidates.find((candidate) => normalizeAgentRoute(candidate))?.fallbacks;
+  // Where the spawned session reads its fallback chain at each hop
+  // (route-fallback-chain.mjs): this agent's route, else Main's.
+  const fallbackSource = { agent: agentName };
   if (agentRoute) {
     return {
       presetName: agentPresetName(agentName),
@@ -41,6 +44,7 @@ export function resolveAgentSpawnPreset(config, args = {}) {
         provider: agentRoute.provider,
         model: agentRoute.model,
         ...(storedFallbacks?.length ? { fallbacks: storedFallbacks.map(normalizeAgentRoute) } : {}),
+        fallbackSource,
         effort: agentRoute.effort,
         fast: agentRoute.fast === true,
         ...(agentRoute.autoEffort === false ? { autoEffort: false } : {}),
@@ -54,12 +58,13 @@ export function resolveAgentSpawnPreset(config, args = {}) {
 
   const mainPreset = !clean(args.preset) ? findPreset(config, config?.default) : null;
   if (normalizeAgentRoute(mainPreset)) {
-    return { presetName: mainPreset.id || mainPreset.name, preset: mainPreset };
+    return { presetName: mainPreset.id || mainPreset.name, preset: { ...mainPreset, fallbackSource } };
   }
 
   const presetName = clean(args.preset);
   if (!presetName) throw new Error(`agent: agent "${agentName}" has no Main model assignment`);
-  const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
+  const stored = findPreset(config, presetName);
+  const preset = stored ? { ...stored, fallbackSource: { preset: presetName } } : synthesizePreset(config, presetName);
   if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
   if (!normalizeAgentRoute(preset)) throw new Error(`agent: preset "${presetName}" has no complete route`);
   return { presetName, preset };

package/src/session-runtime/services/agent-tool/tag-registry.mjs

@@ -121,6 +121,7 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     updateLeadWorkerCwd,
     forgetLeadSession,
     removeWorkerRow,
+    markReleased: index.markReleased,
     refreshTagsFromIndex,
     tags,
     tagAgents: tagMaps.tagAgents,

package/src/session-runtime/services/agent-tool/worker-index/awaiting-user-sync.mjs

@@ -0,0 +1,51 @@
+// worker-index/awaiting-user-sync.mjs
+// A worker row's approval wait (`awaitingUser`), fenced to its session's turn
+// and kept in step with the runtime this process runs for that session. Owns
+// the sessions whose deferred rows still wait in the mutation batch.
+import { clean } from '../helpers.mjs';
+import { applyAwaitingUser, awaitingUserWouldChange } from './approval-wait.mjs';
+
+export function createAwaitingUserSync(store, mgr) {
+  // Sessions whose deferred rows still wait in the batch; reconciled once the
+  // batch lands in the store.
+  const unreconciled = new Set();
+
+  /** Persist (or clear) a worker's approval wait as a field update fenced to
+   *  the session and its turn (`turnAt`, ms): a row whose turn started later is
+   *  left alone. Writes only when a row of that session exists and would
+   *  change, so a Lead's own approvals cost nothing; a row that is not in the
+   *  store yet takes the wait when it lands (reconcileAwaitingUser). */
+  function setAwaitingUser(sessionId, awaitingUser, { turnAt = 0 } = {}) {
+    const fence = {
+      sessionId: clean(sessionId),
+      awaitingUser: awaitingUser === 'approval' ? 'approval' : null,
+      turnAt: Number(turnAt) || 0,
+    };
+    if (!fence.sessionId || !awaitingUserWouldChange(store.readAll(), fence)) return false;
+    store.update((byKey) => applyAwaitingUser(byKey, fence));
+    return true;
+  }
+
+  /** The runtime of a session this process runs is the authority on its
+   *  approval wait (the runtime-liveness counter behind `awaitingUser`): every
+   *  row it creates or refreshes takes that state, so a missed or stale
+   *  transition heals on the next write. No runtime here: not ours to judge. */
+  function reconcileAwaitingUser(sessionId) {
+    const runtime = mgr.getSessionRuntime?.(sessionId);
+    if (runtime) setAwaitingUser(sessionId, runtime.awaitingUser, { turnAt: runtime.askStartedAt });
+  }
+
+  /** A deferred row of `sessionId` is queued; reconciled when its batch lands. */
+  function deferReconcile(sessionId) {
+    unreconciled.add(sessionId);
+  }
+
+  /** The batch landed: reconcile every session whose deferred row it carried. */
+  function reconcileDeferred() {
+    const ids = [...unreconciled];
+    unreconciled.clear();
+    for (const id of ids) reconcileAwaitingUser(id);
+  }
+
+  return { setAwaitingUser, reconcileAwaitingUser, deferReconcile, reconcileDeferred };
+}

package/src/session-runtime/services/agent-tool/worker-index/disposal.mjs

@@ -0,0 +1,55 @@
+// worker-index/disposal.mjs
+// Disposing a worker index: queued rows persist first, then `teardown`
+// releases its registrations; a failed drain leaves them for a retry. Owns
+// the disposed / in-flight dispose state.
+export function createIndexDisposal({ batch, store, teardown }) {
+  let disposed = false;
+  let disposePromise = null;
+
+  async function drainThenTeardown() {
+    batch.flush();
+    await store.flush();
+    teardown();
+  }
+
+  /** Persist queued rows, then release the exit registration. Active rows are
+   *  NOT settled: they are keyed by process pid, which every inline runtime in
+   *  the daemon shares, so settling here would idle other runtimes' workers.
+   *  When the sync flush cannot run (this process's async writer holds the
+   *  lock) the exit hook and store ref stay until the async drain settles. */
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    let flushed = false;
+    try {
+      batch.flush();
+      flushed = store.flushSync();
+    } catch {}
+    if (flushed) {
+      teardown();
+      return;
+    }
+    disposePromise = drainThenTeardown().catch(reopenAfterFailedDrain);
+  }
+
+  /** A failed drain tears nothing down; allow a later dispose to retry it. */
+  function reopenAfterFailedDrain() {
+    disposed = false;
+    disposePromise = null;
+  }
+
+  /** Awaitable dispose: drain everything, then tear down. A failed drain
+   *  rejects and leaves the registrations in place. */
+  function disposeAsync() {
+    if (!disposePromise) {
+      disposed = true;
+      disposePromise = drainThenTeardown().catch((error) => {
+        reopenAfterFailedDrain();
+        throw error;
+      });
+    }
+    return disposePromise;
+  }
+
+  return { dispose, disposeAsync };
+}