mixdog 1.2.6 → 1.3.1

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

@@ -11,6 +11,9 @@ import { resolveMcpOAuthUrl } from '../runtime/agent/orchestrator/mcp/client-con
 import { withAdoptedCopies, withPinnedCollisionNames, withPluginServerIntent } from './mcp-glue/plugin-servers.mjs';
 import { findRegisteredPlugin } from './resource-plugins-api.mjs';
 import { createMcpOAuthLogins } from './mcp-oauth-login.mjs';
+import { connectorById, gmailAppPasswordAccount, gmailAppPasswordValue } from '../runtime/shared/connector-catalog.mjs';
+import { saveMcpOAuthClientSecret } from '../runtime/agent/orchestrator/mcp/oauth-client.mjs';
+import { forgetGmailAppPassword, saveGmailAppPassword } from '../runtime/connectors/gmail-app-password.mjs';
 
 /** The URL a server's OAuth credentials are stored under, or null. */
 function oauthUrlOf(cfg) {
@@ -83,8 +86,17 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     completeMcpLogin,
     getMcpServerOAuthState = () => null,
     probeMcpServerAuth,
+    startMcpServerOAuthSwitch,
+    commitMcpServerOAuthSwitch,
+    gmailAppPassword = { save: saveGmailAppPassword, forget: forgetGmailAppPassword },
+    saveOAuthClientSecret = saveMcpOAuthClientSecret,
   } = deps;
 
+  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({
@@ -95,6 +107,22 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     },
     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.
+    async switchAccount(name, launch, attempt) {
+      const cfg = resolveMcpCatalog().servers[name];
+      const switching = startMcpServerOAuthSwitch(cfg, launch, name);
+      attempt.abort = () => switching.cancel();
+      attempt.answer = (callbackUrl) => switching.answer(callbackUrl);
+      const signIn = await switching.done;
+      const rollback = await commitMcpServerOAuthSwitch(cfg, signIn);
+      const outcome = await reconnectOne(name);
+      if (outcome.connected) return outcome;
+      await rollback();
+      await reconnectOne(name);
+      return { connected: false, error: outcome.error || 'The new sign-in could not connect' };
+    },
     onComplete: (name) => sync.announce('mcp', { detail: { mcpChanges: [{ name, enabled: true }] } }),
   });
   /** The effective config of a server that signs in with MCP OAuth (HTTP/SSE
@@ -130,6 +158,49 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     const owned = name ? pluginMcpServer(name) : null;
     if (owned) throw pluginOwnedError(name, owned.owner);
   };
+  // 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 (Object.values(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 = Object.values(resolveConfiguredMcpCatalog().servers);
+    if (servers.some((cfg) => gmailAppPasswordAccount(cfg) === account)) return false;
+    await gmailAppPassword.forget(account);
+    return true;
+  };
   // Peers reload config from disk on receipt: land the write before publishing.
   const persisted = async () => {
     await flushSkillsSave?.();
@@ -164,11 +235,18 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     async beginMcpOAuthLogin(name, options = {}) {
       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', error? }` */
-    getMcpOAuthLoginStatus(flowId) {
-      return oauthLogins.status(flowId);
+    /** `{ 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);
@@ -186,8 +264,9 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       const { serverName, cfg } = await oauthServerConfig(name);
       // A begin issued meanwhile waits until the credentials are gone.
       return oauthLogins.cancelServer(serverName, async () => {
-        await clearMcpServerOAuth(cfg);
-        return sync.reconnectMcpAndAnnounce({ only: serverName, enabled: cfg.enabled !== false });
+        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
@@ -203,10 +282,18 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     },
     async addMcpServer(input = {}) {
       const { name, config: serverConfig } = normalizeMcpServerInput(input);
+      // A catalog connector's server keeps its catalog id (connector-catalog.mjs).
+      const connector = clean(input.connector);
+      if (connector) {
+        if (!connectorById(connector)) throw new Error(`Unknown connector: ${connector}`);
+        serverConfig.connector = connector;
+      }
       const servers = userServers();
       if (Object.hasOwn(servers, name)) throw new Error(`MCP server already exists: ${name}`);
       const owned = pluginMcpServer(name);
       if (owned) throw new Error(`MCP server already exists: ${name} (provided by plugin "${owned.owner.id}")`);
+      await storeOAuthClientSecret(input, serverConfig);
+      await storeGmailAppPassword(input, serverConfig, true);
       saveServers({ ...servers, [name]: serverConfig });
       const status = await sync.reconnectMcpAndAnnounce({ only: name, enabled: serverConfig.enabled !== false });
       return { name, status };
@@ -232,7 +319,14 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       }
       if (originalName && originalName !== name) delete servers[originalName];
       servers[name] = mergeMcpServerConfig(existing, normalizedInput.config);
+      await storeOAuthClientSecret(input, servers[name], existing);
+      await storeGmailAppPassword(input, servers[name], false);
       saveServers(servers);
+      const previousAccount = gmailAppPasswordAccount(existing);
+      const account = gmailAppPasswordAccount(servers[name]);
+      if (previousAccount !== account) await forgetUnusedGmailAppPassword(previousAccount);
+      // Gmail switched from the Google sign-in to an app password keeps no sign-in.
+      if (account && !previousAccount) await releaseOAuth(existing);
       const status = await sync.reconnectMcpAndAnnounce({
         only: name,
         enabled: servers[name].enabled !== false,
@@ -252,15 +346,15 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       delete servers[serverName];
       saveServers(servers);
       const status = await sync.reconnectMcpAndAnnounce({ drop: [serverName] });
-      // A removed server keeps no OAuth tokens or client registration, unless
-      // another configured server (plugin or disabled ones included, even
-      // with MCP disabled for this runtime) still uses them through the same
-      // exact URL.
-      const url = oauthUrlOf(removed);
-      if (url && !Object.values(resolveConfiguredMcpCatalog().servers).some((cfg) => oauthUrlOf(cfg) === url)) {
-        await clearMcpServerOAuth(removed);
+      // A removed server keeps no sign-in another server does not share: an
+      // app password leaves the keychain (it is revoked at Google only).
+      const account = gmailAppPasswordAccount(removed);
+      if (account) {
+        const forgotten = await forgetUnusedGmailAppPassword(account);
+        return { ...status, signIn: forgotten ? 'removed' : 'shared', revoked: false };
       }
-      return status;
+      const released = await releaseOAuth(removed);
+      return released ? { ...status, ...released } : status;
     },
     async setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);

package/src/session-runtime/resource-skills-api.mjs

@@ -24,6 +24,7 @@ export function createSkillsResourceApi({ deps, sync, decorate }) {
     skillContent,
     addGlobalSkill,
     saveSkillDocument,
+    removeGlobalSkill,
     invalidateSkills,
     getDisabledSkills,
     setDisabledSkills,
@@ -56,6 +57,17 @@ export function createSkillsResourceApi({ deps, sync, decorate }) {
       await sync.announce('skills', { invalidate: false });
       return { skill, status: skillsStatus() };
     },
+    async removeSkill(input = {}) {
+      const removed = removeGlobalSkill(input);
+      // A removed skill leaves no stale disabled entry behind.
+      const disabled = getDisabledSkills?.().disabled;
+      if (Array.isArray(disabled) && disabled.includes(removed.name)) {
+        setDisabledSkills?.(disabled.filter((name) => name !== removed.name));
+        await flushSkillsSave?.();
+      }
+      await sync.announce('skills');
+      return { skill: removed, status: skillsStatus() };
+    },
     async setDisabledSkills(names = []) {
       const result = setDisabledSkills?.(names);
       await flushSkillsSave?.();

package/src/session-runtime/room-member-gate.mjs

@@ -0,0 +1,48 @@
+// A group-room member's tool calls (session/agent-room.mjs). Reads run freely;
+// anything that can change files or state asks the user through the ordinary
+// approval flow, whatever the agent's own permission or hook rules say — even
+// an agent that normally runs auto-approved. A hook's deny still wins.
+import { analyzeShellCommandEffects } from '../runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs';
+
+const READ_ONLY_TOOLS = new Set([
+  'read',
+  'grep',
+  'glob',
+  'find',
+  'list',
+  'code_graph',
+  'load_tool',
+  'skill',
+  'Skill',
+  'recall',
+  'search_memories',
+  'web_search',
+  'web_fetch',
+  'local_fetch',
+  'image_fetch',
+  'ask_user',
+]);
+
+export const ROOM_APPROVAL_REASON = 'Group-room members need your approval before changing anything.';
+
+/** Whether `name(args)` only reads: a read-only tool, or a shell command whose
+ *  every stage the shell analysis classifies as non-mutating. */
+export async function isReadOnlyRoomCall({ name, args, cwd }, analyze = analyzeShellCommandEffects) {
+  if (READ_ONLY_TOOLS.has(name)) return true;
+  if (name !== 'shell' || typeof args?.command !== 'string') return false;
+  try {
+    return (await analyze(args.command, cwd))?.mutationMode === 'none';
+  } catch {
+    return false;
+  }
+}
+
+/** The PreToolUse decision for a room member's call: the hook's own `decision`
+ *  when it denies or the call only reads; otherwise an approval ask that keeps
+ *  any rewrite the hook made. */
+export async function roomMemberToolDecision(call, decision, analyze) {
+  const action = String(decision?.action || decision?.decision || '').toLowerCase();
+  if (action === 'deny' || action === 'block') return decision;
+  if (await isReadOnlyRoomCall(call, analyze)) return decision;
+  return { ...(decision && typeof decision === 'object' ? decision : {}), action: 'ask', reason: ROOM_APPROVAL_REASON };
+}

package/src/session-runtime/route-resolution.mjs

@@ -1,5 +1,5 @@
-// Route resolution against the live runtime record: pick a model for a
-// model-less first turn and refresh the route's effort / Fast / context
+// Route resolution against the live runtime record: refuse a model-less first
+// turn (no auto-pick) and refresh the route's effort / Fast / context
 // fields from provider metadata.
 import { ensureProviderEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
@@ -22,17 +22,11 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
     if (routeHasModel()) return rt.route;
     const models = await runAbortable(signal, () => collectProviderModels());
     throwIfAborted(signal);
-    const picked = models[0] || null;
-    if (!picked) {
+    if (!models?.length) {
       throw new Error('No provider models available. Open /providers to sign in, then /model to choose a model.');
     }
-    rt.route = {
-      ...rt.route,
-      provider: picked.provider,
-      model: picked.id,
-      preset: null,
-    };
-    return rt.route;
+    // Never auto-pick: the user chooses the model.
+    throw new Error('No model selected. Choose a model with /model first.');
   }
 
   async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null, signal = null, lease = null) {

package/src/session-runtime/routine-home-turn.mjs

@@ -0,0 +1,156 @@
+/**
+ * A routine fire (schedule or webhook) is a TURN in its owner bot's home
+ * thread (`sess_home_<agentId>`): the routine's instructions are delivered
+ * there as a queued turn the bot handles itself — doing it or delegating as
+ * in any turn — and its reply in the chat is the result. Nothing else is
+ * created: no run session, no result card.
+ *
+ * The turn waits behind the thread's own work (a user turn, another routine):
+ * it rides the thread's queue as its own `routine` entry (one per turn, never
+ * merged or steered into another), shows as a routine marker row, and selects
+ * skills only from the routine's instructions (`skillSelection`), never from a
+ * webhook payload. While it runs the thread counts as unattended, so its
+ * approvals are held for the owner (held-requests.mjs). Resolves with the
+ * reply once the turn ends; rejects when the turn fails, is cancelled, or the
+ * caller's `signal` aborts (which also aborts the turn once it runs).
+ */
+import { randomUUID } from 'node:crypto';
+import { agentHomeSessionId } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import { routineHumanNeededText } from '../runtime/agent/orchestrator/session/routine-result.mjs';
+import { automationPromptContent } from '../runtime/shared/automation-attachments.mjs';
+import { ROUTINE_LIMITS } from '../runtime/shared/routine-limits.mjs';
+import { normalizeRoutineTrigger, routineTriggerHeader } from '../runtime/shared/routine-trigger.mjs';
+import { agentHomeLiveSurface, scheduleOwnerAgentId } from './agent-home-delivery.mjs';
+import { markUnattendedRun, unattendedRunOf } from './held-requests.mjs';
+
+// Routine turns waiting or running per home thread.
+const waiting = new Map();
+
+const abortError = (signal) =>
+  signal?.reason instanceof Error ? signal.reason : new Error(String(signal?.reason || 'routine run aborted'));
+
+async function defaultLoadSession(sessionId) {
+  const { loadSession } = await import('../runtime/agent/orchestrator/session/store.mjs');
+  return loadSession(sessionId);
+}
+
+function settledError(detail) {
+  if (detail?.status === 'cancelled') return new Error('the routine turn was cancelled');
+  if (detail?.status === 'rejected') return new Error("the bot's chat closed before the routine ran");
+  const error = detail?.error;
+  return new Error(String(error?.message || error || 'the routine turn failed'));
+}
+
+/**
+ * Deliver one fire of routine `name` (`kind` schedule | webhook) to its
+ * owner's home thread. `prompt` is the model-visible body (instructions, plus
+ * a webhook's fenced payload); `skillSelection` its trusted part (default:
+ * the whole body); `event` a short label for the marker (webhook event).
+ */
+export async function runRoutineTurn(
+  {
+    kind,
+    name,
+    ownerAgentId = null,
+    prompt,
+    skillSelection = null,
+    attachments = null,
+    cwd = null,
+    event = '',
+    signal = null,
+  },
+  {
+    surface = agentHomeLiveSurface(),
+    loadSession = defaultLoadSession,
+    limit = ROUTINE_LIMITS.homeQueueLimit,
+    log = (line) => process.stderr.write(`mixdog routines: ${line}\n`),
+  } = {}
+) {
+  const body = String(prompt || '').trim();
+  if (!body) throw new Error(`${kind} "${name}" has no instructions`);
+  if (signal?.aborted) throw abortError(signal);
+  if (typeof surface?.submit !== 'function') throw new Error('routine run: the session service is not running');
+  const agentId = scheduleOwnerAgentId({ ownerAgentId });
+  const homeId = agentHomeSessionId(agentId);
+  const home = await loadSession(homeId);
+  if (!home || home.closed === true) {
+    throw new Error(`the bot "${agentId}" has no chat yet: open it once in the app`);
+  }
+  const queued = waiting.get(homeId) || 0;
+  if (queued >= limit) throw new Error(`${limit} routine runs already wait in this bot's chat`);
+  waiting.set(homeId, queued + 1);
+  const trigger = normalizeRoutineTrigger({ kind, name, event });
+  const header = routineTriggerHeader({ kind, name, project: cwd ? String(cwd) : '' });
+  const content = automationPromptContent(`${header}\n\n${body}`, attachments);
+  return new Promise((resolve, reject) => {
+    let started = false;
+    let aborted = false;
+    let done = false;
+    let unmark = () => {};
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      const left = (waiting.get(homeId) || 1) - 1;
+      if (left > 0) waiting.set(homeId, left);
+      else waiting.delete(homeId);
+      signal?.removeEventListener?.('abort', onAbort);
+    };
+    const finish = (fn, value) => {
+      if (done) return;
+      done = true;
+      fn(value);
+    };
+    const abortTurn = () =>
+      Promise.resolve()
+        .then(() => surface.abort?.(homeId))
+        .catch((error) => log(`aborting ${kind} "${name}" in ${homeId} failed: ${error?.message || error}`));
+    function onAbort() {
+      aborted = true;
+      if (started) void abortTurn();
+      finish(reject, abortError(signal));
+    }
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    const options = {
+      id: `routine_${randomUUID()}`,
+      mode: 'routine',
+      // Runs after the thread's current turn, never steered into it.
+      priority: 'later',
+      isMeta: true,
+      skipSlashCommands: true,
+      restorable: false,
+      // Esc ends this fire; it is never put back in the queue.
+      abortDiscardOnAbort: true,
+      skillSelection: String(skillSelection ?? body),
+      transcriptMeta: { routineTrigger: trigger },
+      onCommitted: () => {
+        if (started) return;
+        started = true;
+        // Nobody watches this turn: its approvals are held for the owner.
+        unmark = markUnattendedRun(homeId, { kind, agentId, name });
+        if (aborted) void abortTurn();
+      },
+      onSettled: (detail) => {
+        // Read before unmarking: a step only a person can do ended the turn.
+        const human = unattendedRunOf(homeId)?.humanNeeded;
+        unmark();
+        release();
+        if (human) finish(reject, new Error(routineHumanNeededText(human.outcome, human.site)));
+        else if (detail?.status === 'done') {
+          finish(resolve, { sessionId: homeId, result: String(detail?.result?.content || '') });
+        } else finish(reject, settledError(detail));
+      },
+    };
+    Promise.resolve()
+      .then(() => surface.submit(homeId, content, options))
+      .then((accepted) => {
+        if (accepted === true) return;
+        release();
+        finish(reject, new Error(`the bot's chat did not accept the ${kind} "${name}"`));
+      })
+      .catch((error) => {
+        release();
+        finish(reject, error);
+      });
+  });
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Routines are bot-based: a schedule or webhook runs in its owner bot's home
+ * thread (routine-home-turn.mjs) and nowhere else. An owner that does not
+ * exist — Mixy before the representative bot was created, a bot archived or
+ * deleted — makes the routine paused: it does not fire, the lists show why,
+ * and a new routine cannot name it.
+ */
+import { MIXY_AGENT_ID } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import { scheduleOwnerAgentId } from './agent-home-delivery.mjs';
+
+/** `ownerProblem` codes and the error each one raises. */
+export const ROUTINE_OWNER_PROBLEMS = Object.freeze({
+  'no-mixy': 'Create the representative bot first.',
+  'owner-deleted': 'The bot that owns this routine no longer exists. Pick another bot.',
+});
+
+let editor = null;
+async function defaultProbe() {
+  if (!editor) {
+    const [{ getPluginData }, { createAgentEditorApi }] = await Promise.all([
+      import('../runtime/agent/orchestrator/config.mjs'),
+      import('./workflow-agents-api/agent-editor.mjs'),
+    ]);
+    editor = createAgentEditorApi({ cfgMod: { getPluginData } });
+  }
+  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],
+  };
+}
+
+/** 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) {
+  const owner = scheduleOwnerAgentId({ ownerAgentId });
+  const check = probe || (await defaultProbe());
+  if (owner === MIXY_AGENT_ID) return check.mixyExists() ? '' : 'no-mixy';
+  return check.presence(owner) === 'deleted' ? 'owner-deleted' : '';
+}
+
+/** Rejects with the owner's problem; resolves when it can own a routine. */
+export async function assertRoutineOwner(ownerAgentId, probe = null) {
+  const problem = await routineOwnerProblem(ownerAgentId, probe);
+  if (problem) throw new Error(ROUTINE_OWNER_PROBLEMS[problem]);
+}

package/src/session-runtime/schedule-session-run.mjs

@@ -1,71 +1,37 @@
 /**
- * Run a schedule as a VISIBLE Mixdog session instead of a hidden agent
- * dispatch. Shared by the engine run-now capability and the channels-worker
- * scheduler so both paths leave the same trail: a resumable session with
- * owner 'user' + sourceType 'schedule' (admitted by the lead-session list
- * filter as its own type, so it shows in desktop Recent / TUI resume), the
- * schedule's provider/model route, and the schedule's project cwd.
+ * Run a schedule fire: its instructions become one turn in its owner bot's
+ * home thread (routine-home-turn.mjs), under the owned-routine guards
+ * (owned-automation-run.mjs). Shared by the engine's "Run now" and the
+ * channels-worker scheduler.
  */
-import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
-import { createSession } from '../runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
-import { askSession } from '../runtime/agent/orchestrator/session/manager/ask-session.mjs';
-import { modelRouteFields, parseScheduleModelRef } from '../runtime/shared/schedule-model-ref.mjs';
-import { migrateCodexRoute } from '../runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs';
-import { automationWorkflowOpts } from './automation-workflow.mjs';
-import { runAutomationTurns } from './automation-agents.mjs';
-import { automationPromptContent } from '../runtime/shared/automation-attachments.mjs';
-
-/** Resolve schedule.model into a {provider,model,effort?,fast?} route. */
-function scheduleRouteFromModelRef(modelRef, config = null) {
-  const ref = parseScheduleModelRef(modelRef);
-  // A model the provider catalog superseded runs on its successor.
-  if (ref && typeof ref === 'object') return migrateCodexRoute(ref);
-  const cfg = config || loadConfig({ secrets: false });
-  const preset = cfg.presets?.find((p) => p.id === ref || p.name === ref);
-  if (!preset) {
-    throw new Error(`schedule model "${ref}" is neither a provider/model route nor a known preset name`);
-  }
-  return modelRouteFields(preset);
-}
+import { markScheduleSkipped } from '../runtime/channels/lib/schedules-db.mjs';
+import { runOwnedAutomation } from './owned-automation-run.mjs';
+import { runRoutineTurn } from './routine-home-turn.mjs';
 
 /**
- * Create the visible schedule session and run the prompt in it.
- * `prompt` overrides schedule.prompt when the caller (channels worker) has
- * already resolved/wrapped the prompt body; the override is used verbatim
- * while the fallback gets a small origin header.
+ * One fire of `schedule`. `prompt` overrides schedule.prompt when the caller
+ * (channels worker) already resolved the body; `attended` marks a person's
+ * "Run now" (no failure backoff).
  */
-export async function runScheduleSession(schedule, { config = null, prompt: promptOverride = null } = {}) {
-  if (!schedule?.name) throw new Error('runScheduleSession: schedule row required');
-  const prompt = String(promptOverride ?? schedule.prompt ?? '').trim();
-  if (!prompt) throw new Error(`schedule "${schedule.name}" has no instructions`);
-  if (!schedule.model) {
-    throw new Error(`schedule "${schedule.name}" has no model configured — edit it and choose a model first`);
-  }
-  const route = scheduleRouteFromModelRef(schedule.model, config);
-  const cwd = schedule.cwd ? String(schedule.cwd) : null;
-  // Every fire is a fresh New task (user decision): one prompt, the
-  // schedule's model/workflow/project, a brand-new session in the sidebar
-  // Automations section (newest per name wins there).
-  const session = createSession({
-    ...modelRouteFields(route),
-    owner: 'user',
-    sourceType: 'schedule',
-    sourceName: schedule.name,
-    ...(cwd ? { cwd } : {}),
-    desktopSession: cwd
-      ? { classification: 'project', projectPath: cwd }
-      : { classification: 'task', projectPath: null },
-    ...automationWorkflowOpts(schedule.workflow),
-  });
-  // The user message is the schedule's instructions verbatim: the desktop
-  // title/preview derive from it, so no "[Scheduled task: …]" header noise.
-  // Stored attachments ride along as composer-style content parts.
-  const content = automationPromptContent(prompt, schedule.attachments);
-  // Agents the run delegates to report back; each result is the next turn.
-  const result = await runAutomationTurns(
-    session.id,
-    () => askSession(session.id, content, null, null, cwd || undefined),
-    (completions, askOpts) => askSession(session.id, completions, null, null, cwd || undefined, undefined, askOpts)
+export async function runScheduleSession(schedule, { attended = false, prompt = null, signal = null } = {}) {
+  const body = String(prompt ?? schedule.prompt ?? '').trim();
+  return runOwnedSchedule(
+    schedule,
+    ({ signal: runSignal }) =>
+      runRoutineTurn({
+        kind: 'schedule',
+        name: schedule.name,
+        ownerAgentId: schedule.ownerAgentId,
+        prompt: body,
+        attachments: schedule.attachments,
+        cwd: schedule.cwd || null,
+        signal: runSignal,
+      }),
+    { attended, signal }
   );
-  return { sessionId: session.id, result: String(result?.content || '') };
+}
+
+/** One owned run of `schedule` (owned-automation-run.mjs). */
+export function runOwnedSchedule(schedule, run, { recordSkip = markScheduleSkipped, ...deps } = {}) {
+  return runOwnedAutomation('schedule', schedule, run, { recordSkip, ...deps });
 }