mixdog 1.2.5 → 1.3.0

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

@@ -98,6 +98,8 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     registry.upsertWorkerSessionDeferred(session, tag, {
       status: 'running',
       stage: 'running',
+      // The send's own task: a restart that ends this turn reports it by id.
+      task_id: job?.taskId,
       turnStartedAt: new Date().toISOString(),
     });
     let handoffMsgStart = 0;
@@ -224,5 +226,26 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     return renderResult({ ...extras, ...views.renderJob(job, false) });
   }
 
-  return { prepareSend, dispatchToExistingSession };
+  // A background-task completion was queued for this worker. A busy worker
+  // takes it at its next tool boundary; an idle one runs a follow-up turn on
+  // an empty prompt, which drains the queued completion (never an empty user
+  // turn). Its answer reaches the owner like any send result.
+  function wakeIdleWorker(sessionId) {
+    const id = clean(sessionId);
+    if (!id || views.isSessionBusy(id)) return false;
+    const session = mgr.getSession(id);
+    if (!session || session.closed) return false;
+    const owner = clean(session.ownerSessionId || session.parentSessionId);
+    const notifyContext = owner
+      ? { callerSessionId: owner, ownerSessionId: owner, clientHostPid: session.clientHostPid || null }
+      : null;
+    void dispatchToExistingSession({ args: {}, session, sessionId: id, prompt: '' }, notifyContext).catch((error) => {
+      try {
+        process.stderr.write(`[agent] completion wake failed session=${id}: ${error?.message || error}\n`);
+      } catch {}
+    });
+    return true;
+  }
+
+  return { prepareSend, dispatchToExistingSession, wakeIdleWorker };
 }

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

@@ -5,6 +5,7 @@
  * flip to running, and the cancellation checks around the turn.
  */
 import { nonNegativeInt, clearAgentStatuslineRoute } from '../helpers.mjs';
+import { closeManagedSession } from '../../../lifecycle/shared.mjs';
 
 export function createDeferredSpawn({
   mgr,
@@ -22,7 +23,7 @@ export function createDeferredSpawn({
   function closePreparedSpawn(prepared, reason = 'agent-task-cancel') {
     if (!prepared?.session?.id) return;
     try {
-      Promise.resolve(mgr.closeSession(prepared.session.id, reason)).catch(() => {});
+      Promise.resolve(closeManagedSession(mgr, prepared.session.id, reason)).catch(() => {});
     } catch {}
     try {
       clearAgentStatuslineRoute(prepared.session.id);

package/src/session-runtime/services/agent-tool/spawn-flow/job-start.mjs

@@ -7,6 +7,7 @@ import { sanitizeTaskMeta, startBackgroundTask } from '../../../../runtime/share
 import { resourceAdmission } from '../../../../runtime/shared/resource-admission.mjs';
 import { clean, terminalPidForContext } from '../helpers.mjs';
 import { renderResult } from '../render.mjs';
+import { closeManagedSession } from '../../../lifecycle/shared.mjs';
 
 /** The completion callback that hands a worker's result back to its caller session; null without a handoff. */
 function handoffNotifier(handoffSessionId, notifySessionCompletion) {
@@ -53,9 +54,9 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
         const currentMeta = task?.meta || jobMeta;
         if (currentMeta?.sessionId) {
           try {
-            Promise.resolve(mgr.closeSession(currentMeta.sessionId, 'agent-task-cancel', { tombstone: false })).catch(
-              () => {}
-            );
+            Promise.resolve(
+              closeManagedSession(mgr, currentMeta.sessionId, 'agent-task-cancel', { tombstone: false })
+            ).catch(() => {});
           } catch {}
         }
         setImmediate(notifyStatusChange);

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

@@ -9,6 +9,7 @@ import {
   agentDefinitionExists,
   clean,
   normalizeAgentName,
+  readAgentFrontmatterKind,
   readAgentFrontmatterPermission,
   resolvePrompt,
   terminalPidForContext,
@@ -18,8 +19,13 @@ import { normalizeAgentPermission } from '../../../../runtime/shared/markdown-fr
 import { resolveAgentSpawnPreset } from '../spawn-preset.mjs';
 import { AGENT_OWNER } from '../../../../runtime/agent/orchestrator/agent-owner.mjs';
 import { workspaceCwdLock } from '../../../workspace/admission-gate.mjs';
+import { isContactAgentId } from '../../../../runtime/agent/orchestrator/runtime-core/workflow-ids.mjs';
+import { AGENT_MODE, resolveSessionMode } from '../../../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { MIXY_AGENT_ID } from '../../../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { mixyDisplayName } from '../../../../runtime/agent/orchestrator/session/mixy-name.mjs';
 
 export function createSpawnPlanner({
+  mgr = null,
   cfgMod,
   dataDir,
   STANDALONE_SOURCE_ROOT,
@@ -44,6 +50,18 @@ export function createSpawnPlanner({
     if (isAgentDisabled(config, agent)) {
       throw new Error(`agent spawn: agent "${agent}" is turned off`);
     }
+    // Only Mixy hands work to a contact agent; any other agent-mode Lead
+    // delegates to sub-agents alone (its catalog lists no contact either).
+    if (isContactAgentId(agent, readAgentFrontmatterKind(agent, dataDir, STANDALONE_SOURCE_ROOT))) {
+      const callerId = clean(context?.callerSessionId || context?.sessionId);
+      const caller = (callerId && mgr?.getSession?.(callerId)) || null;
+      const { mode, agentId } = resolveSessionMode({ session: caller, sessionId: callerId });
+      if (mode === AGENT_MODE && agentId !== MIXY_AGENT_ID) {
+        throw new Error(
+          `agent spawn: only ${mixyDisplayName()} (the representative agent) can hand work to the contact agent "${agent}"; delegate to a sub-agent instead`
+        );
+      }
+    }
     const agentPermission = readAgentFrontmatterPermission(agent, dataDir, STANDALONE_SOURCE_ROOT);
     const agentPerm = normalizeAgentPermission(agentPermission) || null;
     const { presetName, preset } = resolveAgentSpawnPreset(config, args);
@@ -56,10 +74,7 @@ export function createSpawnPlanner({
     // Workers share their Lead's execution root. While the Lead runs in its
     // worktree, that root is locked: neither args.cwd nor an inherited
     // (pre-transition) cwd can send a worker elsewhere.
-    const lockedCwd = workspaceCwdLock([
-      context?.ownerSessionId,
-      context?.callerSessionId || context?.sessionId,
-    ]);
+    const lockedCwd = workspaceCwdLock([context?.ownerSessionId, context?.callerSessionId || context?.sessionId]);
     const baseCwd = resolve(lockedCwd || callerCwd || defaultCwd || process.cwd());
     const workerCwd = !lockedCwd && clean(args.cwd) ? resolve(baseCwd, args.cwd) : baseCwd;
     const prompt = await resolvePrompt(args, workerCwd);

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

@@ -58,8 +58,10 @@ export function createSpawnPreparer({
   ensureProvider,
   sessionSurface = null,
   refreshTagsFromSessions,
+  mgr = null,
 }) {
   const { resolveSpawnPlan, spawnSessionSpec } = createSpawnPlanner({
+    mgr,
     cfgMod,
     dataDir,
     STANDALONE_SOURCE_ROOT,

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

@@ -39,9 +39,13 @@ export function createSpawnRunner({
   emitSubagentEvent,
   sessionSurface = null,
   createTurnReviewCollector,
+  onWorkerCompletionQueued = null,
 }) {
   // Owner/worker completion notification lives in ../notify.mjs.
-  const { workerNotifyFn, notifyOwnerAgentCompletionEarly } = createNotify(mgr, { notifySessionCompletion });
+  const { workerNotifyFn, notifyOwnerAgentCompletionEarly } = createNotify(mgr, {
+    notifySessionCompletion,
+    onWorkerCompletionQueued,
+  });
 
   // Idle-progress watchdogs (shared sweep timer) live in
   // agent-watchdog-registry.mjs.

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

@@ -32,14 +32,16 @@ export function createTagLookup({ tags, mgr, readWorkerRows, reaper, getLiveSess
     const rows = [];
     const seen = new Set();
     const tombstones = reaper.tagTombstoneIndex();
-    const add = (session, fallbackTag = '') => {
+    // `loaded`: `session` is getLiveSession's own answer (not a catalog
+    // summary), so consumers may reuse it instead of loading it again.
+    const add = (session, fallbackTag = '', loaded = false) => {
       const tag = agentTagOf(session) || clean(fallbackTag);
       if (!tag || !session?.id || session.closed === true) return;
       if (isLeadPoolAgent(session.agent)) return;
       if (!sessionMatchesContext(session, context)) return;
       if (seen.has(session.id)) return;
       seen.add(session.id);
-      rows.push({ tag, session });
+      rows.push(loaded ? { tag, session, loaded: true } : { tag, session });
     };
     const addIndexRow = (row) => {
       const tag = clean(row?.tag);
@@ -70,9 +72,12 @@ export function createTagLookup({ tags, mgr, readWorkerRows, reaper, getLiveSess
       }
     }
     for (const [tag, sessionId] of tags.entries()) {
+      // add() drops an id already listed; loading it first (a whole-session
+      // read for an idle worker) was pure cost on every status pulse.
+      if (seen.has(sessionId)) continue;
       const session = getLiveSession(sessionId);
       if (session && reaper.tombstoneBlocksScan(session, tag, tombstones)) continue;
-      add(session, tag);
+      add(session, tag, true);
     }
     return rows;
   }

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

@@ -112,6 +112,9 @@ export function createTagRegistry({ dataDir, cfgMod, mgr }) {
     readWorkerRows,
     writeWorkerRows: index.writeWorkerRows,
     flushWorkerIndexMutations: index.flushWorkerIndexMutations,
+    recoverStaleWorkerRows: index.recoverStaleWorkerRows,
+    pendingRestartFailures: index.pendingRestartFailures,
+    markRestartNotified: index.markRestartNotified,
     upsertWorkerSession: index.upsertWorkerSession,
     upsertWorkerSessionDeferred,
     upsertLeadSession,

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

@@ -55,6 +55,9 @@ export function normalizeWorkerRows(value) {
       // Why a `failed` row failed (row-liveness, a watchdog stop). Always
       // present, so a later whole-row write clears a stale reason.
       failureReason: clean(row.failureReason) || null,
+      // When the owner was told this row's turn died with a process restart;
+      // always present, so new work on the row starts unnotified.
+      restartNotified: clean(row.restartNotified) || null,
       permission: clean(row.permission) || null,
       toolPermission: clean(row.toolPermission) || null,
       messages: positiveInt(row.messages) || 0,
@@ -112,6 +115,7 @@ export function workerRowFromSession(session, fallbackTag = '', extra = {}, getS
     task_id: clean(extra.task_id || extra.taskId) || null,
     error: clean(extra.error) || null,
     failureReason: clean(extra.failureReason) || null,
+    restartNotified: clean(extra.restartNotified) || null,
     permission: clean(session?.permission) || null,
     toolPermission: clean(session?.toolPermission) || null,
     messages: Array.isArray(session?.messages) ? session.messages.length : 0,

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

@@ -161,14 +161,19 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     });
   }
 
-  // Startup recovery: stale active rows settle — as failed when the process
-  // that ran their turn is gone (the turn never finished), otherwise to idle —
-  // and an approval wait left behind by a runtime that is gone (daemon
-  // restart) is cleared.
-  function recoverStaleWorkerRows() {
+  // Startup recovery: stale active rows settle — as failed when another
+  // process ran their turn (it is gone, or is the predecessor still shutting
+  // down: either way the turn never finished), otherwise to idle — and an
+  // approval wait left behind by a runtime that is gone (daemon restart) is
+  // cleared. `deadOnly` (later sweeps) settles only rows whose runtime is
+  // provably dead, never a live process's quiet turn.
+  function recoverStaleWorkerRows({ deadOnly = false } = {}) {
     const now = Date.now();
     const rows = store.readAll();
-    const staleActive = rows.filter((row) => liveness.isStaleActive(row, now));
+    const isStale = deadOnly
+      ? (row) => isActiveWorkerRow(row) && runtimeDied(row)
+      : (row) => liveness.isStaleActive(row, now);
+    const staleActive = rows.filter(isStale);
     const staleWaits = rows.some(isStaleApprovalWait);
     if (!staleActive.length && !staleWaits) return false;
     if (staleActive.length) {
@@ -176,12 +181,11 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
         for (const row of staleActive) {
           const key = workerRowKey(row);
           const current = byKey.get(key);
-          if (!current || !liveness.isStaleActive(current, now)) continue;
+          if (!current || !isStale(current)) continue;
+          const ranElsewhere = positiveInt(current.runtimePid) && positiveInt(current.runtimePid) !== process.pid;
           byKey.set(
             key,
-            runtimeDied(current)
-              ? liveness.failedRow(current, now, PROCESS_RESTART_FAILURE)
-              : liveness.idleRow(current, now)
+            ranElsewhere ? liveness.failedRow(current, now, PROCESS_RESTART_FAILURE) : liveness.idleRow(current, now)
           );
         }
       });
@@ -190,6 +194,34 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     return true;
   }
 
+  const isUnnotifiedRestartFailure = (row) =>
+    row.status === 'failed' &&
+    row.failureReason === PROCESS_RESTART_FAILURE &&
+    Boolean(clean(row.ownerSessionId)) &&
+    !row.restartNotified;
+
+  /** Rows whose turn a process restart ended and whose owner has not been told
+   *  yet — whoever settled the row (this process at startup, or the
+   *  predecessor's exit flush). Read-only: the caller enqueues the owner's
+   *  notification durably, THEN calls `markRestartNotified`, so a crash in
+   *  between retries (the notification's stable id makes the retry exactly-once). */
+  function pendingRestartFailures() {
+    return store.readAll().filter(isUnnotifiedRestartFailure);
+  }
+
+  /** Stamp these rows as told, once their notification is durably queued. */
+  function markRestartNotified(rows) {
+    const stamp = new Date().toISOString();
+    store.write((byKey) => {
+      for (const row of rows) {
+        const key = workerRowKey(row);
+        const current = byKey.get(key);
+        if (!current || !isUnnotifiedRestartFailure(current)) continue;
+        byKey.set(key, { ...current, restartNotified: stamp });
+      }
+    });
+  }
+
   function flushWorkerIndexOnExit() {
     batch.flush();
     flushActiveWorkerRows();
@@ -285,5 +317,7 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     flushActiveWorkerRows,
     flushWorkerIndexOnExit,
     recoverStaleWorkerRows,
+    pendingRestartFailures,
+    markRestartNotified,
   };
 }

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

@@ -9,6 +9,7 @@ import { liveAgentStatusRow } from './agent-tool/job-views/session-progress.mjs'
 import { createSpawnFlow } from './agent-tool/spawn-flow.mjs';
 import { createSendFlow } from './agent-tool/send-flow.mjs';
 import { createCloseFlow } from './agent-tool/close-flow.mjs';
+import { createRestartFailureNotifier } from './agent-tool/restart-notify.mjs';
 import { createTerminalTrace } from './agent-tool/terminal-trace.mjs';
 import { createAgentExecute } from './agent-tool/execute.mjs';
 import { createTurnReviewCollector } from './agent-tool/turn-review.mjs';
@@ -70,8 +71,24 @@ export function createStandaloneAgent({
   }
 
   const registry = createTagRegistry({ dataDir, cfgMod, mgr });
+  // Tasks the previous process was running died with it: tell their owners.
+  // Later sweeps also catch rows the predecessor settled as it shut down.
+  const notifyRestartFailures = createRestartFailureNotifier({
+    pendingRestartFailures: registry.pendingRestartFailures,
+    markRestartNotified: registry.markRestartNotified,
+    mgr,
+    notifySessionCompletion,
+  });
+  const sweepRestartFailures = () => {
+    registry.recoverStaleWorkerRows({ deadOnly: true });
+    notifyRestartFailures();
+  };
+  notifyRestartFailures();
   const views = createJobViews({ ...registry, mgr, reg, cfgMod, DEFAULT_SPAWN_PREP_TIMEOUT_MS });
+  // Late-bound: the send flow that wakes an idle worker is built after spawn.
+  let wakeIdleWorker = null;
   const spawnFlow = createSpawnFlow({
+    onWorkerCompletionQueued: (sessionId) => wakeIdleWorker?.(sessionId),
     ...registry,
     ...views,
     mgr,
@@ -96,6 +113,7 @@ export function createStandaloneAgent({
     views,
     spawnFlow,
   });
+  wakeIdleWorker = sendFlow.wakeIdleWorker;
   const closeFlow = createCloseFlow({ mgr, registry, views });
   const terminalTrace = createTerminalTrace({ registry });
   const execute = createAgentExecute({
@@ -116,6 +134,7 @@ export function createStandaloneAgent({
       void awaitKeychainPrewarm();
       return { workers: [], jobs: [], scope: null };
     }
+    sweepRestartFailures();
     const scopedContext = agentScope({}, context);
     const ownerSession = callerSessionForContext(scopedContext);
     const pid = terminalPidForContext(scopedContext);
@@ -134,6 +153,7 @@ export function createStandaloneAgent({
       void awaitKeychainPrewarm();
       return [];
     }
+    sweepRestartFailures();
     const scopedContext = agentScope({ recover: true }, context);
     registry.refreshTagsFromSessions({ scanSessions: true, context: scopedContext });
     return views.list({ scanSessions: false, context: scopedContext });

package/src/session-runtime/services/channel-admin.mjs

@@ -23,13 +23,14 @@ import {
   setEndpointEnabled as dbSetEndpointEnabled,
 } from '../../runtime/channels/lib/webhooks-db.mjs';
 import { normalizeAutomationAttachments } from '../../runtime/shared/automation-attachments.mjs';
-import { migrateCodexModelRef } from '../../runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs';
+import { assertRoutineOwner, routineOwnerProblem } from '../routine-owner.mjs';
 import { hasEnabledAutomation } from '../../runtime/shared/automation-presence.mjs';
 import { resolveScheduleTimezone, validateScheduleCron } from '../../runtime/shared/schedule-time.mjs';
 import { pgClusterExists } from '../../runtime/memory/lib/pg/adapter.mjs';
 import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 import { readHookPublicBase } from '../../runtime/channels/lib/webhook/relay-tunnel.mjs';
 import { WEBHOOK_TEST_FIELD, WEBHOOK_TEST_HEADER } from '../../runtime/channels/lib/webhook/request-handler.mjs';
+import { MIXY_AGENT_ID, agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 
@@ -187,7 +188,7 @@ function parseAtDatetime(at) {
 // Map the store's def shape onto the flat display shape every schedule reader
 // (channelSetup, renderChannelStatus, TUI pickers) consumes: `.time` renders
 // the cron or the one-shot datetime, `.route` the channel/session target.
-function scheduleToDisplay(s) {
+function scheduleToDisplay(s, ownerProblem = '') {
   return {
     name: s.name,
     description: s.description || '',
@@ -195,26 +196,85 @@ function scheduleToDisplay(s) {
     whenAt: s.whenAt || undefined,
     whenCron: s.whenCron || undefined,
     timezone: s.timezone || undefined,
-    // Shown (and re-saved by the editor) on the catalog successor of a superseded model.
-    model: s.model ? migrateCodexModelRef(s.model) : undefined,
     cwd: s.cwd || undefined,
-    workflow: s.workflow || undefined,
     attachments: s.attachments || undefined,
     enabled: s.enabled !== false,
     instructions: s.prompt,
     route: 'session',
+    // The bot it belongs to: each run is a turn in that bot's chat.
+    owner: s.ownerAgentId || MIXY_AGENT_ID,
+    // Why it is paused for its owner (routine-owner.mjs); absent when it runs.
+    ...(ownerProblem ? { ownerProblem } : {}),
+    nextFireAt: isoOrUndefined(s.nextFireAt),
+    lastSuccessAt: isoOrUndefined(s.lastSuccessAt),
+    lastFailedAt: isoOrUndefined(s.lastFailedAt),
+    lastSkippedAt: isoOrUndefined(s.lastSkippedAt),
+    ...routineHealth(s),
+  };
+}
+
+// Failures in a row (the routine pauses itself at the limit) and the results
+// of finished runs still not queued for the owner: `{ count, failed, error }`,
+// `failed` when the queue refused one (the app offers a retry).
+function routineHealth(row) {
+  const entries = Object.values(row.resultDelivery || {}).filter(Boolean);
+  const refused = entries.filter((entry) => entry.state === 'failed').at(-1);
+  return {
+    consecutiveFailures: Number(row.consecutiveFailures) || 0,
+    ...(entries.length
+      ? {
+          undelivered: {
+            count: entries.length,
+            failed: Boolean(refused),
+            ...(refused?.error ? { error: String(refused.error) } : {}),
+          },
+        }
+      : {}),
+  };
+}
+
+function isoOrUndefined(value) {
+  if (!value) return undefined;
+  const at = new Date(value);
+  return Number.isNaN(at.getTime()) ? undefined : at.toISOString();
+}
+
+// A schedule's or webhook's owner: an explicit agent id, else the saved owner
+// on an overwrite, else Mixy.
+function scheduleOwner(owner, existing) {
+  const value = String(owner ?? '').trim();
+  if (value) {
+    if (!agentHomeSessionId(value)) throw new Error(`schedule owner "${value}" is not a valid agent id`);
+    return value;
+  }
+  return existing?.ownerAgentId || MIXY_AGENT_ID;
+}
+
+/** Each owner's problem (routine-owner.mjs), probed once per owner. */
+function ownerProblems() {
+  const seen = new Map();
+  return (ownerAgentId) => {
+    const owner = ownerAgentId || MIXY_AGENT_ID;
+    if (!seen.has(owner))
+      seen.set(
+        owner,
+        routineOwnerProblem(owner).catch(() => '')
+      );
+    return seen.get(owner);
   };
 }
 
 export async function listSchedules() {
   const rows = await dbListSchedules();
-  return rows.map(scheduleToDisplay);
+  const problemOf = ownerProblems();
+  return Promise.all(rows.map(async (row) => scheduleToDisplay(row, await problemOf(row.ownerAgentId))));
 }
 
 // Register or update a schedule in the PG store. Recurring input maps `time`
 // (+ optional `days`) to a cron; one-shot input maps an `at` datetime; the two
 // are mutually exclusive (also enforced by the store's when_at/when_cron XOR).
-// Every schedule runs as a visible app session and requires a model.
+// Every schedule runs as a turn in its owner bot's chat; a bot that does not
+// exist (no representative bot yet, an archived bot) cannot own one.
 export async function saveSchedule({
   name,
   description = '',
@@ -222,26 +282,26 @@ export async function saveSchedule({
   at,
   timezone,
   days,
-  model,
   cwd,
-  workflow,
   attachments,
   enabled,
   instructions,
+  owner,
   overwrite = false,
 } = {}) {
   const id = assertScheduleName(name);
   const body = String(instructions || '').trim();
   if (!body) throw new Error('schedule instructions are required');
-  const scheduleModel = String(model || '').trim();
-  if (!scheduleModel) throw new Error('schedule model is required — choose a model before saving');
   const hasTime = time != null && String(time).trim() !== '';
   const hasAt = at != null && String(at).trim() !== '';
   if (hasTime && hasAt) throw new Error('provide either `time` (recurring) or `at` (one-shot), not both');
   if (!hasTime && !hasAt) throw new Error('either `time` (recurring cron) or `at` (one-shot datetime) is required');
-  if (overwrite !== true && (await dbGetSchedule(id))) {
+  const existing = await dbGetSchedule(id);
+  if (overwrite !== true && existing) {
     throw new Error(`schedule "${id}" already exists`);
   }
+  const ownerAgentId = scheduleOwner(owner, existing);
+  await assertRoutineOwner(ownerAgentId);
   const whenCron = hasTime ? validateScheduleCron(foldDaysIntoCron(normalizeCron(time), days)) : null;
   const whenAt = hasAt ? parseAtDatetime(at) : null;
   const scheduleTimezone = hasTime ? resolveScheduleTimezone(timezone) : null;
@@ -253,14 +313,13 @@ export async function saveSchedule({
     timezone: scheduleTimezone,
     target: 'session',
     channelId: null,
-    model: scheduleModel,
     cwd: cwd ? String(cwd).trim() : null,
-    workflow: workflow ? String(workflow).trim() : null,
     attachments: normalizeAutomationAttachments(attachments),
     delivery: 'app',
     prompt: body,
     enabled: enabled !== false,
     nextFireAt: whenAt,
+    ownerAgentId,
   });
   automationProbe.invalidate();
   return scheduleToDisplay(saved);
@@ -287,13 +346,13 @@ export async function setScheduleEnabled(name, enabled) {
 // store's migration hook.
 async function listWebhooks() {
   const endpoints = await dbListEndpoints();
-  return endpoints.map((ep) => ({
+  const problemOf = ownerProblems();
+  const problems = await Promise.all(endpoints.map((ep) => problemOf(ep.ownerAgentId)));
+  return endpoints.map((ep, index) => ({
     name: ep.name,
     description: ep.description || '',
     parser: ep.parser || 'github',
-    ...(ep.model ? { model: migrateCodexModelRef(ep.model) } : {}),
     ...(ep.cwd ? { cwd: ep.cwd } : {}),
-    ...(ep.workflow ? { workflow: ep.workflow } : {}),
     ...(ep.attachments ? { attachments: ep.attachments } : {}),
     enabled: ep.enabled,
     // The store never projects the plaintext secret through list paths; it
@@ -302,6 +361,16 @@ async function listWebhooks() {
     secret: undefined,
     instructions: ep.instructions,
     route: 'session',
+    // The bot it belongs to: each run is a turn in that bot's chat.
+    owner: ep.ownerAgentId || MIXY_AGENT_ID,
+    ...(problems[index] ? { ownerProblem: problems[index] } : {}),
+    lastEventAt: isoOrUndefined(ep.lastEventAt),
+    lastSuccessAt: isoOrUndefined(ep.lastSuccessAt),
+    lastFailedAt: isoOrUndefined(ep.lastFailedAt),
+    lastSkippedAt: isoOrUndefined(ep.lastSkippedAt),
+    // Whether "Run now" has a received payload to re-run (never the payload).
+    hasLastPayload: ep.hasLastPayload === true,
+    ...routineHealth(ep),
   }));
 }
 
@@ -310,12 +379,11 @@ export async function saveWebhook({
   description = '',
   parser = 'github',
   secret,
-  model,
   cwd,
-  workflow,
   attachments,
   enabled,
   instructions,
+  owner,
   overwrite = false,
 } = {}) {
   const id = assertName(name, 'webhook name');
@@ -327,9 +395,12 @@ export async function saveWebhook({
   }
   const body = String(instructions || '').trim();
   if (!body) throw new Error('webhook instructions are required');
-  if (overwrite !== true && (await dbLoadEndpoint(id))) {
+  const existing = await dbLoadEndpoint(id);
+  if (overwrite !== true && existing) {
     throw new Error(`webhook "${id}" already exists`);
   }
+  const ownerAgentId = scheduleOwner(owner, existing);
+  await assertRoutineOwner(ownerAgentId);
   // Secret semantics: an explicit value always wins; an EMPTY value on an
   // overwrite PRESERVES the stored secret (editing instructions must not
   // silently rotate the key the external service was configured with); only
@@ -343,23 +414,21 @@ export async function saveWebhook({
     description: String(description || '').trim(),
     parser: nextParser,
     channelId: null,
-    model: model ? String(model).trim() : null,
     cwd: cwd ? String(cwd).trim() : null,
-    workflow: workflow ? String(workflow).trim() : null,
     attachments: normalizeAutomationAttachments(attachments),
     delivery: 'app',
     secret: secretValue,
     instructions: body,
     enabled: enabled !== false,
+    ownerAgentId,
   });
   automationProbe.invalidate();
   return {
     name: id,
+    owner: saved.ownerAgentId || ownerAgentId,
     description: saved.description,
     parser: saved.parser,
-    ...(saved.model ? { model: saved.model } : {}),
     ...(saved.cwd ? { cwd: saved.cwd } : {}),
-    ...(saved.workflow ? { workflow: saved.workflow } : {}),
     ...(saved.attachments ? { attachments: saved.attachments } : {}),
     ...(enabled === false ? { enabled: false } : {}),
     secret: secretValue,

package/src/session-runtime/services/memory-access.mjs

@@ -0,0 +1,37 @@
+// Whose memory a session reads and writes (runtime/memory/lib/
+// core-memory-access.mjs enforces it). Mixy is the Lead configuration, so the
+// user's own sessions (an ordinary Lead session, Mixy's home) act as Mixy; an
+// agent's home thread and its room member sessions act as that agent; a
+// schedule or webhook run acts for its owning agent (`ownerAgentId`, stamped
+// at creation); a delegated agent as its own agent id.
+import { MIXY_AGENT_ID, agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
+import { scheduleCallerScope } from './schedule-access.mjs';
+
+const validAgentId = (value) => {
+  const id = typeof value === 'string' ? value.trim() : '';
+  return id && agentHomeSessionId(id) ? id : '';
+};
+
+/** The `memory_caller` `{ kind, agentId }` of a calling session record:
+ *  'human' and 'agent' are conversations with the user, 'room-member' and
+ *  'headless' unattended runs. */
+export function memoryCallerScope(session) {
+  const scope = scheduleCallerScope(session);
+  if (scope.kind === 'human') return { kind: 'human', agentId: MIXY_AGENT_ID };
+  if (scope.kind !== 'headless') return scope;
+  const delegated = isAgentOwner(session) || Boolean(session?.parentSessionId);
+  return {
+    kind: 'headless',
+    agentId: validAgentId(session?.ownerAgentId) || (delegated ? validAgentId(session?.agent) : ''),
+  };
+}
+
+/** The agent whose own memory a session's prompt carries: its home thread's,
+ *  room member's or run owner's agent, Mixy for the user's Lead sessions, and
+ *  none for a delegated agent. `session` is the live record when there is
+ *  one, else the reserved id and creation profile. */
+export function injectedMemoryAgentId({ session = null, sessionId = '', profile = null } = {}) {
+  return resolveSessionMode({ session, sessionId, profile }).agentId;
+}