mixdog 1.2.6 → 1.3.0

package/src/runtime/shared/connector-catalog.mjs

@@ -0,0 +1,230 @@
+// The built-in connector catalog: services a user connects with one click
+// from Desktop (Extensions → 커넥터) or from a chat card the setup tool's
+// `connect_connector` action surfaces. Each entry declares its backend
+// explicitly:
+//   oauth   — a remote MCP server that signs in with MCP OAuth;
+//   apiKey  — an MCP server that takes one key (an HTTP header or a stdio
+//             environment variable);
+//   builtin — a Mixdog built-in feature (GitHub is the GitHub CLI of the
+//             Git & GitHub built-in, never a GitHub MCP);
+// A connected catalog service is an ordinary user MCP server whose config
+// carries `connector: <id>`. An existing custom server is never adopted into
+// the catalog row.
+
+import { connectorTrigger } from './connector-triggers.mjs';
+
+// `oauthClient` names a pre-registered client the runtime supplies
+// (mcp/oauth-client.mjs: 'google') in place of dynamic client registration;
+// `scopes` are then the ones requested.
+const oauth = (url, client = {}) => Object.freeze({ kind: 'oauth', url, ...client });
+
+const GOOGLE_SCOPE = 'https://www.googleapis.com/auth';
+// The Google access each built-in connector asks for: the one place to widen
+// it (e.g. gmail.readonly). openid + email name the signed-in account.
+export const GOOGLE_SCOPES = Object.freeze({
+  gmail: Object.freeze(['openid', 'email', `${GOOGLE_SCOPE}/gmail.send`]),
+  calendar: Object.freeze(['openid', 'email', `${GOOGLE_SCOPE}/calendar.events`]),
+  drive: Object.freeze(['openid', 'email', `${GOOGLE_SCOPE}/drive.file`]),
+});
+// Gmail / Calendar / Drive are Mixdog's built-in Google connectors
+// (runtime/connectors/google-mcp.mjs), answered in-process at a reserved
+// address and signed in with Mixdog's Google client. `askTools` ask before
+// they run unless the agent set them.
+const google = (service, scopes, askTools) =>
+  oauth(`https://${service}.mixdog.invalid/mcp`, { oauthClient: 'google', scopes, askTools });
+// Gmail can also connect with a Google app password instead of the sign-in:
+// IMAP and SMTP over TLS (runtime/connectors/gmail-app-password.mjs), answered
+// in-process at its own reserved address. Its server is still the Gmail
+// connector (`connector: 'gmail'`, so Gmail's askTools apply to its tools of
+// the same names); the account rides in a header, the app password lives only
+// in the keychain.
+export const GMAIL_APP_PASSWORD = Object.freeze({
+  url: 'https://gmail-imap.mixdog.invalid/mcp',
+  accountHeader: 'X-Mixdog-Gmail-Account',
+  helpUrl: 'https://myaccount.google.com/apppasswords',
+});
+const apiKey = (spec) => Object.freeze({ kind: 'apiKey', ...spec });
+
+export const CONNECTOR_CATALOG = Object.freeze(
+  [
+    { id: 'airtable', name: 'Airtable', backend: oauth('https://mcp.airtable.com/mcp') },
+    { id: 'confluence', name: 'Confluence', backend: oauth('https://mcp.atlassian.com/v1/mcp/authv2') },
+    { id: 'dropbox', name: 'Dropbox', backend: oauth('https://mcp.dropbox.com/mcp') },
+    { id: 'github', name: 'GitHub', backend: Object.freeze({ kind: 'builtin', feature: 'git' }) },
+    {
+      id: 'gmail',
+      name: 'Gmail',
+      backend: google('gmail', GOOGLE_SCOPES.gmail, ['send_email']),
+    },
+    // Calendar and Drive are offered only to a user who entered their own
+    // Google OAuth client (Connectors → add custom → 내 Google 키): `ownKey`.
+    // Existing connections keep working; Mixy and the chat cards never offer them.
+    {
+      id: 'google-calendar',
+      name: 'Google Calendar',
+      ownKey: true,
+      backend: google('calendar', GOOGLE_SCOPES.calendar, ['delete_event']),
+    },
+    {
+      id: 'google-drive',
+      name: 'Google Drive',
+      ownKey: true,
+      backend: google('drive', GOOGLE_SCOPES.drive, []),
+    },
+    {
+      id: 'hugging-face',
+      name: 'Hugging Face',
+      backend: apiKey({
+        url: 'https://huggingface.co/mcp',
+        header: 'Authorization',
+        prefix: 'Bearer ',
+        keyUrl: 'https://huggingface.co/settings/tokens',
+      }),
+    },
+    { id: 'jira', name: 'Jira', backend: oauth('https://mcp.atlassian.com/v1/mcp/authv2') },
+    { id: 'linear', name: 'Linear', backend: oauth('https://mcp.linear.app/mcp') },
+    { id: 'notion', name: 'Notion', backend: oauth('https://mcp.notion.com/mcp') },
+    {
+      id: 'postgres',
+      name: 'Postgres',
+      backend: apiKey({
+        command: 'npx',
+        args: ['-y', '@microsoft/postgres-mcp@0.2.0', 'run'],
+        env: 'POSTGRES_MCP_CONNECTION_STRING',
+        keyUrl: 'https://github.com/microsoft/postgres-mcp/blob/main/USAGE.md',
+        placeholder: 'postgresql://user:password@host:5432/db',
+      }),
+    },
+    { id: 'sentry', name: 'Sentry', backend: oauth('https://mcp.sentry.dev/mcp') },
+    {
+      id: 'stripe',
+      name: 'Stripe',
+      backend: apiKey({
+        url: 'https://mcp.stripe.com',
+        header: 'Authorization',
+        prefix: 'Bearer ',
+        keyUrl: 'https://dashboard.stripe.com/apikeys',
+        placeholder: 'rk_live_…',
+      }),
+    },
+    { id: 'supabase', name: 'Supabase', backend: oauth('https://mcp.supabase.com/mcp') },
+    { id: 'trello', name: 'Trello', backend: oauth('https://mcp.trello.com/v1') },
+    { id: 'vercel', name: 'Vercel', backend: oauth('https://mcp.vercel.com') },
+    // The ids are the deferred-tool manifest's curated keys: a server named by
+    // its id gets that one-line trigger (connector-triggers.mjs).
+  ].map((entry) => Object.freeze({ ...entry, trigger: connectorTrigger(entry.id) }))
+);
+
+/** The ids offered to everyone (the setup tool's `connect_connector`): the
+ *  catalog minus the own-key-only Google services. */
+export const CONNECTOR_IDS = Object.freeze(CONNECTOR_CATALOG.filter((entry) => !entry.ownKey).map((entry) => entry.id));
+
+/** The catalog entry for `id`, or null. */
+export function connectorById(id) {
+  return CONNECTOR_CATALOG.find((entry) => entry.id === id) || null;
+}
+
+const urlKey = (url) =>
+  String(url || '')
+    .trim()
+    .replace(/\/+$/, '')
+    .toLowerCase();
+
+/** The catalog id a configured MCP server connects: its `connector` marker,
+ *  '' for none (or a marker the catalog no longer knows). */
+export function connectorOfServer(cfg) {
+  const marker = typeof cfg?.connector === 'string' ? cfg.connector : '';
+  return connectorById(marker) ? marker : '';
+}
+
+/** The permission a catalog connector's tool has when nothing set its own:
+ *  `needs_approval` for the high-risk tools it names, else `auto`. */
+export function connectorToolDefault(connectorId, tool) {
+  const backend = connectorById(connectorId)?.backend;
+  return backend?.askTools?.includes(tool) ? 'needs_approval' : 'auto';
+}
+
+const EMAIL = /^[^\s@<>(),;:"]+@[^\s@<>(),;:"]+\.[^\s@<>(),;:".]+$/;
+
+/** A Gmail address as typed (trimmed, lowercased), or '' when it is none. */
+export function gmailAddress(value) {
+  const address = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  return EMAIL.test(address) ? address : '';
+}
+
+/** A Google app password as typed, its spaces removed; '' unless it then
+ *  has the 16 characters Google issues. */
+export function gmailAppPasswordValue(value) {
+  const password = String(value ?? '').replace(/\s+/g, '');
+  return password.length === 16 ? password : '';
+}
+
+/** The account of a Gmail app-password server config, '' for any other. */
+export function gmailAppPasswordAccount(cfg) {
+  if (urlKey(cfg?.url) !== urlKey(GMAIL_APP_PASSWORD.url)) return '';
+  const headers = cfg?.headers && typeof cfg.headers === 'object' ? cfg.headers : {};
+  const header = GMAIL_APP_PASSWORD.accountHeader.toLowerCase();
+  const key = Object.keys(headers).find((name) => name.toLowerCase() === header);
+  return key ? gmailAddress(headers[key]) : '';
+}
+
+/** The MCP server input that connects Gmail under `name` as `email` with an
+ *  app password. `appPassword` only travels to the host, which checks it
+ *  with Gmail and keeps it in the keychain; it never reaches the config. */
+export function gmailAppPasswordServerInput(name, email, password) {
+  const address = gmailAddress(email);
+  if (!address) throw new Error('GMAIL_APP_PASSWORD_ADDRESS: Enter a Gmail address.');
+  const appPassword = gmailAppPasswordValue(password);
+  if (!appPassword) throw new Error('GMAIL_APP_PASSWORD_FORMAT: An app password has 16 characters.');
+  return {
+    name,
+    type: 'http',
+    url: GMAIL_APP_PASSWORD.url,
+    headers: { [GMAIL_APP_PASSWORD.accountHeader]: address },
+    connector: 'gmail',
+    appPassword,
+  };
+}
+
+/** Whether several accounts of catalog connector `entry` can be connected at
+ *  once: Gmail (also by app password), Calendar and Drive with the Google
+ *  sign-in. Other remote servers keep one (their tokens and URL are shared). */
+export function connectorMultiAccount(entry) {
+  return entry?.backend?.kind === 'oauth' && entry.backend.oauthClient === 'google';
+}
+
+/** The MCP server input that connects catalog entry `entry` under `name`
+ *  (oauth / apiKey); `key` fills an apiKey backend; `extraAccount`
+ *  makes it one more account of a multi-account connector. */
+export function connectorServerInput(entry, name, key = '', { extraAccount = false } = {}) {
+  const { backend } = entry;
+  if (backend.kind === 'oauth') {
+    // Tokens are stored per exact server URL, so another account of the same
+    // connector needs its own URL; the in-process Google servers ignore the query.
+    const url =
+      extraAccount && connectorMultiAccount(entry) ? `${backend.url}?account=${encodeURIComponent(name)}` : backend.url;
+    return { name, type: 'http', url, connector: entry.id };
+  }
+  if (backend.kind !== 'apiKey') throw new Error(`${entry.name} is not an MCP connector`);
+  const value = String(key || '').trim();
+  if (!value) throw new Error(`${entry.name} needs a key`);
+  if (backend.url) {
+    return {
+      name,
+      type: 'http',
+      url: backend.url,
+      headers: { [backend.header]: `${backend.prefix || ''}${value}` },
+      connector: entry.id,
+    };
+  }
+  return {
+    name,
+    type: 'stdio',
+    command: backend.command,
+    args: [...backend.args],
+    env: { [backend.env]: value },
+    connector: entry.id,
+  };
+}

package/src/runtime/shared/connector-triggers.d.mts

@@ -0,0 +1,3 @@
+export declare const CONNECTOR_TRIGGER_MAX_CHARS: number;
+export declare const CONNECTOR_TRIGGERS: Readonly<Record<string, string>>;
+export declare function connectorTrigger(serverId: string): string;

package/src/runtime/shared/connector-triggers.mjs

@@ -0,0 +1,43 @@
+// Curated selection triggers for catalog connectors (MCP servers). A catalog
+// entry carries its line as `trigger`; the deferred-tool manifest lists each
+// connected server once as `- mcp__<server id>: <trigger>`, so one line must
+// say what the connector is for (plus a close negative where useful), in
+// English, at most CONNECTOR_TRIGGER_MAX_CHARS characters.
+export const CONNECTOR_TRIGGER_MAX_CHARS = 100;
+
+export const CONNECTOR_TRIGGERS = Object.freeze({
+  github: 'GitHub repos, issues, pull requests, Actions and code search; not local Git history or diffs.',
+  notion: 'Notion pages, databases and workspace search; create or update team docs and notes.',
+  linear: 'Linear issues, projects, cycles and comments; create, triage or update tickets.',
+  sentry: 'Sentry issues, events, stack traces and releases; triage production errors.',
+  gmail: 'Gmail: send email; with an app password also search, read, archive, label, star, trash.',
+  'google-calendar': 'Google Calendar events on the primary calendar; list, search, create, update or delete.',
+  'google-drive': 'Google Drive files Mixdog created or was given; search, read or create; not local files.',
+  jira: 'Jira issues, projects, sprints and comments; JQL search, create or transition tickets.',
+  confluence: 'Confluence spaces and pages; search, read or edit the team wiki; not Jira tickets.',
+  dropbox: 'Dropbox files and folders; search, read, upload or share cloud files; not local files.',
+  trello: 'Trello boards, lists and cards; create, move or update cards.',
+  airtable: 'Airtable bases, tables and records; query, create or update rows.',
+  stripe: 'Stripe customers, payments, invoices, subscriptions and refunds; billing data and actions.',
+  vercel: 'Vercel projects, deployments, domains and logs; deploy status and build errors.',
+  supabase: 'Supabase projects: Postgres tables and SQL, auth, storage and edge functions.',
+  postgres: 'PostgreSQL schemas, tables and SQL queries on a connected database; not local files.',
+  'hugging-face': 'Hugging Face Hub models, datasets, Spaces and papers; not local GGUF model setup.',
+});
+
+// Server ids differ only in separators and case (google_calendar, huggingface).
+const triggerKey = (id) =>
+  String(id || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '');
+const TRIGGERS_BY_KEY = new Map(Object.entries(CONNECTOR_TRIGGERS).map(([id, line]) => [triggerKey(id), line]));
+
+/** The curated trigger of the catalog connector `serverId`, or ''. */
+export function connectorTrigger(serverId) {
+  // Another account of a connector is named `<id>-2`, `<id>-3`…
+  return (
+    TRIGGERS_BY_KEY.get(triggerKey(serverId)) ||
+    TRIGGERS_BY_KEY.get(triggerKey(String(serverId || '').replace(/[-_]\d+$/, ''))) ||
+    ''
+  );
+}

package/src/runtime/shared/google-oauth-client.mjs

@@ -0,0 +1,24 @@
+// Mixdog's own Google OAuth client (a "Desktop app" client, marked "Use this
+// client for an AI-powered agent"), used by the Gmail, Google Calendar and
+// Google Drive catalog connectors instead of dynamic client registration,
+// which Google does not offer. Google treats desktop clients as public: the
+// id and its non-confidential secret ship with the app, and every sign-in
+// uses PKCE (S256), state and a loopback redirect
+// (developers.google.com/identity/protocols/oauth2/native-app).
+//
+// The values come only from the environment; the source ships none, so a
+// build without them offers no built-in Google sign-in (the user's own
+// Google client still works).
+
+const value = (name) => String(process.env[name] || '').trim();
+
+/** `{ clientId, clientSecret }` of Mixdog's Google client, or null when this
+ *  build has none. */
+export function googleOAuthClient() {
+  const clientId = value('MIXDOG_GOOGLE_OAUTH_CLIENT_ID');
+  if (!clientId) return null;
+  return { clientId, clientSecret: value('MIXDOG_GOOGLE_OAUTH_CLIENT_SECRET') };
+}
+
+/** Google issues a refresh token only for `access_type=offline`. */
+export const GOOGLE_AUTH_PARAMS = Object.freeze({ access_type: 'offline' });

package/src/runtime/shared/held-request-host.d.mts

@@ -0,0 +1,12 @@
+export interface HeldRequestPushEvent {
+  sessionId: string;
+  agentId: string;
+  agentName: string;
+  requestId: string;
+}
+export function registerHeldRequestResolver(resolver: (id: string, decision: unknown) => boolean): () => void;
+export function resolveHeldRequest(id: string, decision: unknown): boolean;
+export function registerHeldRequestNotifier(notifier: (event: HeldRequestPushEvent) => void): () => void;
+export function notifyHeldRequest(event: Partial<HeldRequestPushEvent>): void;
+export function recordRunOwner(sessionId: string, agentId: string): void;
+export function runOwnerOf(sessionId: string): string;

package/src/runtime/shared/held-request-host.mjs

@@ -0,0 +1,71 @@
+// Runtime ↔ desktop-service channel for held requests of unattended runs
+// (session-runtime/held-requests.mjs). The daemon's held-request registry
+// registers the resolver; the desktop service hosted in this daemon registers
+// a notifier that sends the sanitized phone push. The session API answers a
+// held request through resolveHeldRequest, whatever session it was sent from.
+//
+// Deliberately dependency-free: the desktop service bundle imports this file
+// too, and both copies share one registry through a global symbol.
+
+const KEY = Symbol.for('mixdog.heldRequestHost.v1');
+
+function registry() {
+  globalThis[KEY] ??= { resolver: null, notifiers: [], runOwners: new Map() };
+  return globalThis[KEY];
+}
+
+const RUN_OWNER_LIMIT = 500;
+/** Remember which agent an unattended run session belongs to, so its pushes
+ *  follow that agent's notification mute after the run ends (bounded, newest kept). */
+export function recordRunOwner(sessionId, agentId) {
+  const owners = registry().runOwners;
+  owners.delete(sessionId);
+  owners.set(String(sessionId), String(agentId));
+  while (owners.size > RUN_OWNER_LIMIT) owners.delete(owners.keys().next().value);
+}
+
+export function runOwnerOf(sessionId) {
+  return registry().runOwners.get(String(sessionId || '')) || '';
+}
+
+/** `resolver(id, decision) → boolean` (true when `id` was a pending held request). */
+export function registerHeldRequestResolver(resolver) {
+  registry().resolver = resolver;
+  return () => {
+    if (registry().resolver === resolver) registry().resolver = null;
+  };
+}
+
+export function resolveHeldRequest(id, decision) {
+  const { resolver } = registry();
+  return typeof resolver === 'function' && String(id || '').startsWith('held_')
+    ? resolver(id, decision) === true
+    : false;
+}
+
+/** `notifier({ sessionId, agentId, agentName, requestId })`: one per desktop service. */
+export function registerHeldRequestNotifier(notifier) {
+  const entry = { notifier };
+  registry().notifiers.push(entry);
+  return () => {
+    const list = registry().notifiers;
+    const index = list.indexOf(entry);
+    if (index >= 0) list.splice(index, 1);
+  };
+}
+
+/** Hand one held request to every registered notifier. Carries ids and the
+ *  agent's name only: never the tool, its arguments or any text. */
+export function notifyHeldRequest({ sessionId, agentId, agentName, requestId }) {
+  const event = {
+    sessionId: String(sessionId || ''),
+    agentId: String(agentId || ''),
+    agentName: String(agentName || ''),
+    requestId: String(requestId || ''),
+  };
+  for (const { notifier } of registry().notifiers) {
+    try {
+      notifier(event);
+    } catch {}
+  }
+}

package/src/runtime/shared/plain-preview.d.mts

@@ -0,0 +1 @@
+export function plainPreviewText(text: unknown): string;

package/src/runtime/shared/plain-preview.mjs

@@ -0,0 +1,28 @@
+// A messenger preview line reads as plain text, as KakaoTalk shows it: the
+// markdown a reply was written in (bold, headings, list markers, quotes,
+// code fences and spans, links, images) is dropped, its words kept.
+
+/** `text` without markdown syntax, whitespace folded to single spaces. */
+export function plainPreviewText(text) {
+  // HTML comments never show in markdown (a greeting's suggestions ride one).
+  return String(text ?? '')
+    .replace(/<!--[\s\S]*?(?:-->|$)/g, ' ')
+    .replace(/^[ \t]*(`{3,}|~{3,})[^\n]*$/gm, ' ')
+    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+    .replace(/^[ \t]{0,3}#{1,6}[ \t]+/gm, '')
+    .replace(/^[ \t]*>[ \t]?/gm, '')
+    .replace(/^[ \t]*(?:[-*+]|\d+[.)])[ \t]+(?:\[[ xX]\][ \t]+)?/gm, '')
+    .replace(/^[ \t]*(?:[-*_][ \t]*){3,}$/gm, ' ')
+    .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, '$2')
+    .replace(/(^|[^\w*])\*(?=\S)([^*\n]*?\S)\*(?!\w)/g, '$1$2')
+    .replace(/(^|[^\w_])_(?=\S)([^_\n]*?\S)_(?!\w)/g, '$1$2')
+    .replace(/~~(?=\S)([\s\S]*?\S)~~/g, '$1')
+    .replace(/`+([^`\n]*)`+/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, PREVIEW_CAP);
+}
+
+/** A safety cap only: the row clamps the shown text to two lines. */
+const PREVIEW_CAP = 200;

package/src/runtime/shared/routine-limits.d.mts

@@ -0,0 +1,11 @@
+export declare const ROUTINE_LIMITS: Readonly<{
+  backoffBaseMs: number;
+  pauseAfterFailures: number;
+  homeQueueLimit: number;
+}>;
+
+export declare function routineBackoffRemaining(
+  state: { consecutiveFailures?: unknown; lastFailedAt?: unknown } | null | undefined,
+  now?: number,
+  limits?: typeof ROUTINE_LIMITS
+): number;

package/src/runtime/shared/routine-limits.mjs

@@ -0,0 +1,21 @@
+// Safeguards of owned routines (schedules and webhook endpoints, see
+// session-runtime/owned-automation-run.mjs): after a failure the next
+// unattended fire waits `backoffBaseMs * 2^(n-1)` (n consecutive failures)
+// and the routine switches itself off at `pauseAfterFailures`; a home thread
+// holds at most `homeQueueLimit` routine turns waiting (and as many queued
+// rows posted from outside its turns). Runs themselves are
+// unlimited: no concurrency cap and no deadline.
+export const ROUTINE_LIMITS = Object.freeze({
+  backoffBaseMs: 60_000,
+  pauseAfterFailures: 5,
+  homeQueueLimit: 200,
+});
+
+/** How long (ms) an unattended fire still waits after the routine's
+ *  `consecutiveFailures`, the latest at `lastFailedAt`; 0 when it may run. */
+export function routineBackoffRemaining(state, now = Date.now(), limits = ROUTINE_LIMITS) {
+  const failures = Number(state?.consecutiveFailures) || 0;
+  const at = state?.lastFailedAt ? new Date(state.lastFailedAt).getTime() : Number.NaN;
+  if (failures < 1 || !Number.isFinite(at)) return 0;
+  return Math.max(0, at + limits.backoffBaseMs * 2 ** (failures - 1) - now);
+}

package/src/runtime/shared/routine-trigger.d.mts

@@ -0,0 +1,10 @@
+export interface RoutineTrigger {
+  kind: 'schedule' | 'webhook';
+  name: string;
+  event?: string;
+}
+
+export declare function routineTriggerHeader(input: { kind: string; name: string; project?: string }): string;
+export declare function stripRoutineTriggerHeader(text: unknown): string;
+export declare function normalizeRoutineTrigger(value: unknown): RoutineTrigger | null;
+export declare function routineTriggerField(value: unknown): { routineTrigger?: RoutineTrigger };

package/src/runtime/shared/routine-trigger.mjs

@@ -0,0 +1,44 @@
+// A routine fire delivered into its bot's home thread as a turn
+// (session-runtime/routine-home-turn.mjs): the model-visible header line that
+// opens the turn's prompt, and the `routineTrigger` marker its user row
+// carries (live, persisted in meta.transcript, restored) so a chat paints it
+// as a routine marker instead of a user bubble.
+
+const HEADER_PREFIX = '[Routine trigger]';
+const KINDS = new Set(['schedule', 'webhook']);
+
+/** The first line of a routine turn's prompt: which routine fired and how to
+ *  treat the turn. Only the turn's content carries it, never the system
+ *  prompt, so the thread's prompt cache is untouched. */
+export function routineTriggerHeader({ kind, name, project = '' }) {
+  const what = kind === 'webhook' ? 'webhook' : 'schedule';
+  return [
+    `${HEADER_PREFIX} Your ${what} "${String(name)}" fired.`,
+    'Carry out its instructions below now, yourself or by delegating; nobody is watching this turn, so approvals wait for the user.',
+    'Reply in this chat with the result.',
+    ...(project ? [`Project folder: ${project}`] : []),
+  ].join(' ');
+}
+
+/** `text` without the header line a routine turn opens with. */
+export function stripRoutineTriggerHeader(text) {
+  const value = String(text ?? '');
+  if (!value.startsWith(HEADER_PREFIX)) return value;
+  const end = value.indexOf('\n');
+  return end < 0 ? '' : value.slice(end + 1).replace(/^\n+/, '');
+}
+
+/** A well-formed `{ kind, name, event? }` marker, or null. */
+export function normalizeRoutineTrigger(value) {
+  if (!value || typeof value !== 'object') return null;
+  const name = typeof value.name === 'string' ? value.name.trim().slice(0, 200) : '';
+  if (!name || !KINDS.has(value.kind)) return null;
+  const event = typeof value.event === 'string' ? value.event.trim().slice(0, 200) : '';
+  return { kind: value.kind, name, ...(event ? { event } : {}) };
+}
+
+/** The `routineTrigger` field of a transcript row (absent when none). */
+export function routineTriggerField(value) {
+  const trigger = normalizeRoutineTrigger(value?.routineTrigger);
+  return trigger ? { routineTrigger: trigger } : {};
+}

package/src/runtime/shared/schedule-model-ref.mjs

@@ -1,13 +1,12 @@
-// schedule.model wire format shared by the channels-worker scheduler and the
-// engine-side run-now dispatch: either a config.presets id/name (legacy) or a
-// direct "provider/model[@effort][+fast][+noauto][?parameter=value]" route string
-// written by the desktop schedule editor (`+noauto`: Auto effort off for the
-// route; absent means on). Slash-form values become direct route
-// objects, which agent-dispatch consumes without a presets lookup.
-// The optional route fields an automation run carries, from a preset, a
-// maintenance slot or a parsed route ref. One shape so schedule and webhook
-// runs cannot drift when a field is added. modelParameters is copied so a
-// stored preset can never be mutated through the run.
+// Model route-ref wire format (task sessions, provider model caches): either a
+// config.presets id/name (legacy) or a direct
+// "provider/model[@effort][+fast][+noauto][?parameter=value]" route string
+// (`+noauto`: Auto effort off for the route; absent means on). Slash-form
+// values become direct route objects, which agent-dispatch consumes without a
+// presets lookup.
+// The optional route fields a run carries, from a preset, a maintenance slot
+// or a parsed route ref. modelParameters is copied so a stored preset can
+// never be mutated through the run.
 export function modelRouteFields(slot = {}) {
   return {
     provider: slot.provider,

package/src/runtime/shared/slow-span.mjs

@@ -3,8 +3,8 @@
 // monotonic clock the owner heartbeat uses (performance.now), completed spans
 // over `minMs` land in a bounded ring, and spans over `slowMs` are logged as
 // `[slow-op] <label> <ms>`. When the event loop stalls, `describe(from, to)`
-// names the spans that overlapped the stall window. Spans carry labels, phase
-// durations and sizes only — never payloads.
+// names the spans that overlapped the stall window. Spans carry labels and
+// phase durations only — never payloads.
 
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { performance } from 'node:perf_hooks';
@@ -36,18 +36,11 @@ export function markPhase(name) {
   span.mark = t;
 }
 
-/** Records a size (count/bytes) on the caller's span. */
-export function noteSpanSize(size) {
-  const span = current.getStore();
-  if (span && Number.isFinite(size)) span.size = size;
-}
-
 const round = (ms) => Math.round(ms);
 
 function formatSpan(span) {
   const phases = span.phases.map(([name, ms]) => `${name}=${round(ms)}`).join(' ');
-  const size = span.size === undefined ? '' : ` size=${span.size}`;
-  return `${span.label} ${round(span.ms)}ms${phases ? ` ${phases}` : ''}${size}`;
+  return `${span.label} ${round(span.ms)}ms${phases ? ` ${phases}` : ''}`;
 }
 
 export function createSlowSpans({
@@ -70,7 +63,6 @@ export function createSlowSpans({
         end: span.end,
         ms: span.ms,
         phases: span.phases,
-        size: span.size,
       });
       if (ring.length > capacity) ring.shift();
     }
@@ -90,7 +82,7 @@ export function createSlowSpans({
     /** Runs `fn` inside a span; markPhase/annotateSpan inside it attach to this span. */
     async trace(label, fn) {
       const start = now();
-      const span = { label: String(label), start, mark: start, now, phases: [], size: undefined };
+      const span = { label: String(label), start, mark: start, now, phases: [] };
       try {
         return await current.run(span, fn);
       } finally {

package/src/runtime/shared/statusline/statusline-segments.mjs

@@ -200,7 +200,8 @@ async function refreshShellJobsStatus(ownerPid) {
       // its owner retires the record. Its root pid may be gone while a
       // descendant lives, so the owner's liveness decides, not the root's.
       const unconfirmed = detail?.terminationUnconfirmed === true;
-      if (unconfirmed ? !isPidAlive(ownerByJob.get(id) || 0) : !(await isShellJobAlive(detail, p, dir, id))) continue;
+      if (unconfirmed ? !isHeldShellJobAlive(detail, ownerByJob.get(id)) : !(await isShellJobAlive(detail, p, dir, id)))
+        continue;
       // A foreground command is awaited in its own tool card; listing it here
       // made every short command flash in and out of the shell list. Only
       // backgrounded jobs (including promoted ones) are background work.
@@ -326,6 +327,17 @@ function summarizeShellJobs({ count, oldestMs, jobs, bySession }) {
   return { count, elapsedLabel, jobs, sessions };
 }
 
+// A held record lives while its owner process does. Once its owner session
+// has closed, it also needs a process left to hold: the root or a survivor
+// its termination watch last reported. Without one it is an orphan whose
+// processes are gone, and it resolves instead of staying unconfirmed.
+function isHeldShellJobAlive(detail, ownerPid) {
+  if (!isPidAlive(ownerPid || 0)) return false;
+  if (detail?.ownerSessionClosed !== true) return true;
+  const survivors = Array.isArray(detail?.survivorPids) ? detail.survivorPids : [];
+  return [detail?.pid, ...survivors].some((pid) => isPidAlive(positiveInt(pid)));
+}
+
 async function isShellJobAlive(detail, detailPath, dir, id) {
   const pid = positiveInt(detail?.pid);
   if (!pid) return false;

package/src/runtime/shared/transcript-metadata.mjs

@@ -2,6 +2,7 @@
 // These pure helpers keep live rows, persisted messages and restored rows on
 // the same field contract without rewriting older display-only transcripts.
 import { displayModelName } from './model-display.mjs';
+import { routineTriggerField } from './routine-trigger.mjs';
 
 export function transcriptRouteMetadataFields(value) {
   if (!value || typeof value !== 'object') return {};
@@ -76,10 +77,19 @@ export function persistedUserTranscriptMetadata(value) {
     // The turn's change-record key (the outer prompt id), so a restored user
     // row still addresses its turn's Undo/Reapply.
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    // Every submission a merged queued batch delivered as this turn.
+    ...submissionIdsField(value.submissionIds),
     ...attachmentsField(value.attachments),
+    // A routine fire delivered as this turn (routine-trigger.mjs).
+    ...routineTriggerField(value),
   };
 }
 
+function submissionIdsField(value) {
+  const ids = Array.isArray(value) ? value.filter((id) => typeof id === 'string' && id) : [];
+  return ids.length ? { submissionIds: ids } : {};
+}
+
 function attachmentsField(value) {
   const attachments = normalizeMessageAttachments(value);
   return attachments.length ? { attachments } : {};