mixdog 1.2.6 → 1.3.0

package/src/session-runtime/tool-policy-refresh.mjs

@@ -1,7 +1,8 @@
 // Refresh the empty Lead session's model-facing tool surface and BP1/BP3
 // layers after workflow or search/memory settings change. Conversation
 // sessions keep their frozen schema; the next new session picks up the
-// updated policy.
+// updated policy. The one exception is a workflow switch made in the session
+// itself (switchSessionWorkflow), which rebuilds that conversation's policy.
 import { sessionHasConversationMessages } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { toSessionWorkflowMeta } from '../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import {
@@ -21,7 +22,25 @@ import {
 } from '../runtime/agent/orchestrator/session/manager/session-tool-surface.mjs';
 import { finalizeSessionToolList } from '../runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
 import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
+import {
+  AGENT_MODE,
+  isRoutineSource,
+  resolveSessionMode,
+  sessionModeOf,
+} from '../runtime/agent/orchestrator/session/agent-mode.mjs';
 import { unusedModelEditToolName } from '../runtime/shared/edit-tool-dialect.mjs';
+import { MIXY_AGENT_ID } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import {
+  refreshSessionBp3Environment,
+  withPresentedWorkspaceSlices,
+} from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { stageWorkflowSwitchNotice } from '../runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs';
+import { markToolSurfaceMigrated } from '../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
+import { agentProfileRevision, leadRosterRevision } from '../runtime/agent/orchestrator/context/role-instructions.mjs';
+import { recordTranscriptBoundary } from './model-route/set-route.mjs';
+
+const WORKFLOW_SWITCH_BUSY = 'The session is running a turn; wait for it to finish.';
+const AGENT_PROFILE_INTENT = 'agent_profile';
 
 function toolNames(list) {
   return (Array.isArray(list) ? list : [])
@@ -46,16 +65,28 @@ function rewriteSystemHeading(session, heading, nextContent) {
   if (target) replaceMessageContent(messages, target, nextContent);
 }
 
-function rewriteBp3Core(session, nextCore) {
+function bp3Message(session) {
   const messages = Array.isArray(session.messages) ? session.messages : [];
-  const bp3 =
+  return (
     messages.find((message) => message?.role === 'system' && message.cacheTier === 'tier3') ||
     messages.find(
       (message) =>
         message?.role === 'system' &&
         typeof message.content === 'string' &&
         message.content.startsWith('# Active Workflow:')
-    );
+    )
+  );
+}
+
+// The BP3 core the session's prompt carries now (split layout: the whole
+// tier3 block; combined: the stored core beside the environment).
+function presentedBp3Core(session) {
+  return session.bp3EnvSplit === true ? bp3Message(session)?.content : session.bp3CoreContext;
+}
+
+function rewriteBp3Core(session, nextCore) {
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  const bp3 = bp3Message(session);
   if (!bp3 || typeof bp3.content !== 'string') return;
   if (session.bp3EnvSplit === true) {
     // Split layout: the environment lives in its own cacheTier:'env' system
@@ -69,6 +100,27 @@ function rewriteBp3Core(session, nextCore) {
   session.bp3CoreContext = nextCore || '';
 }
 
+// A Lead's workflow slices (orchestration, agent and contact catalogs) for its
+// mode, Mixy's with the contacts.
+function leadPartsFor(session, leadPromptParts) {
+  return leadPromptParts({
+    agentMode: sessionModeOf(session) === AGENT_MODE,
+    mixy: resolveSessionMode({ session }).agentId === MIXY_AGENT_ID,
+  });
+}
+
+// A conversation keeps its `# Session` block: the legacy combined layout
+// rebuilds the tier3 block from the new core (rooted where it was).
+function rewriteConversationBp3Core(session, nextCore) {
+  if (session.bp3EnvSplit !== true && typeof session.bp3CoreContext === 'string') {
+    const previous = session.bp3CoreContext;
+    session.bp3CoreContext = nextCore;
+    if (refreshSessionBp3Environment(session, session.cwd)) return;
+    session.bp3CoreContext = previous;
+  }
+  rewriteBp3Core(session, nextCore);
+}
+
 export function createToolPolicyRefresh({
   getSession,
   getRoute,
@@ -137,15 +189,11 @@ export function createToolPolicyRefresh({
     );
   }
 
-  async function refreshEmptySessionToolPolicy() {
-    invalidatePreSessionToolSurface?.();
-    const session = getSession?.();
-    if (!session?.id) return { appliedToCurrentSession: true };
-    if (!admitsRefresh(session)) return { appliedToCurrentSession: false };
-    // Older records contain only compiled prompt text; rebuilding would guess
-    // away custom instructions. Keep that immutable material for every owner.
-    const identity = session.promptIdentity;
-    if (!identity) return { appliedToCurrentSession: false, reason: 'missing-prompt-identity' };
+  // The policy `config` gives `session`, computed without touching the
+  // session, so a turn that starts during the async rebuild cannot lose tools
+  // to it. `conversation`: the rebuilt BP3 core keeps the instruction files
+  // and core memory the prompt presents now (withPresentedWorkspaceSlices).
+  async function stagePolicy(session, identity, config, { conversation = false } = {}) {
     const ownerIsAgent = isAgentOwner(session);
     const schemaAllowedTools = honoredSchemaAllowlist(session.schemaAllowedTools, {
       ownerIsAgent,
@@ -155,11 +203,13 @@ export function createToolPolicyRefresh({
 
     const {
       summary: workflow,
-      context: leadWorkflowContext,
-      packContext,
+      leadPromptParts,
+      packContext: workflowContext,
       orchestrationMode,
-    } = activeWorkflowContext(getConfig(), getDataDir());
-    const workflowContext = ownerIsAgent ? packContext : leadWorkflowContext;
+    } = activeWorkflowContext(config, getDataDir());
+    const sessionMode = sessionModeOf(session);
+    const agentMode = sessionMode === AGENT_MODE;
+    const leadWorkflowParts = ownerIsAgent ? {} : leadPartsFor(session, leadPromptParts);
     const denied = [
       ...session.callerDisallowedTools,
       ...featureDisallowedTools(),
@@ -168,8 +218,6 @@ export function createToolPolicyRefresh({
       .map((name) => String(name || ''))
       .filter(Boolean);
 
-    // Stage: everything below is computed without touching the session, so a
-    // turn that starts during the async rebuild cannot lose tools to it.
     const baseRules =
       identity.skipAgentRules || toolFreeRole
         ? ''
@@ -179,29 +227,190 @@ export function createToolPolicyRefresh({
             provider: getRoute()?.provider,
             model: getRoute()?.model,
           });
-    const coreMemoryContext = await leadCoreMemoryContext();
+    const coreMemoryContext = conversation ? '' : await leadCoreMemoryContext();
     const { sessionMarkerCore } = composeSystemPrompt({
       ...sessionRolePromptFields(identity, {
         ownerIsAgent,
         toolFreeRole,
         delegationFree: delegationDisabled(session, ownerIsAgent),
+        sessionMode,
+        routine: isRoutineSource(session.sourceType),
       }),
       provider: getRoute()?.provider,
       workflowContext,
+      ...leadWorkflowParts,
       coreMemoryContext,
-      // The rebuilt core keeps (or newly applies) the instruction-files setting.
-      instructionFilesContext: toolFreeRole ? null : loadInstructionFilesContext?.(session) || null,
+      // The rebuilt core keeps (or newly applies) the instruction-files
+      // setting; agent mode carries none.
+      instructionFilesContext:
+        conversation || toolFreeRole || agentMode ? null : loadInstructionFilesContext?.(session) || null,
     });
+    return {
+      workflow,
+      orchestrationMode,
+      sessionMode,
+      denied,
+      schemaAllowedTools,
+      ownerIsAgent,
+      baseRules,
+      core: conversation ? withPresentedWorkspaceSlices(session, sessionMarkerCore) : sessionMarkerCore,
+    };
+  }
+
+  // Apply a staged policy synchronously; the BP3 core is the caller's.
+  function applyPolicy(session, staged) {
+    session.workflow = toSessionWorkflowMeta(staged.workflow);
+    session.orchestrationMode = staged.orchestrationMode;
+    session.sessionMode = staged.sessionMode;
+    applyToolDenials(session, staged.denied, staged.schemaAllowedTools, staged.ownerIsAgent);
+    rewriteSystemHeading(session, '# Tool Use', staged.baseRules);
+    session.updatedAt = Date.now();
+  }
+
+  async function refreshEmptySessionToolPolicy() {
+    invalidatePreSessionToolSurface?.();
+    const session = getSession?.();
+    if (!session?.id) return { appliedToCurrentSession: true };
+    if (!admitsRefresh(session)) return { appliedToCurrentSession: false };
+    // Older records contain only compiled prompt text; rebuilding would guess
+    // away custom instructions. Keep that immutable material for every owner.
+    const identity = session.promptIdentity;
+    if (!identity) return { appliedToCurrentSession: false, reason: 'missing-prompt-identity' };
+    const staged = await stagePolicy(session, identity, getConfig());
     // Apply: re-check admission after the await, then mutate synchronously.
     if (!admitsRefresh(session)) return { appliedToCurrentSession: false };
-    session.workflow = toSessionWorkflowMeta(workflow);
-    session.orchestrationMode = orchestrationMode;
-    applyToolDenials(session, denied, schemaAllowedTools, ownerIsAgent);
-    rewriteSystemHeading(session, '# Tool Use', baseRules);
-    rewriteBp3Core(session, sessionMarkerCore);
-    session.updatedAt = Date.now();
+    applyPolicy(session, staged);
+    rewriteBp3Core(session, staged.core);
     return { appliedToCurrentSession: true };
   }
 
-  return { refreshEmptySessionToolPolicy };
+  /**
+   * Switch the current coding session's workflow mid-conversation (the
+   * composer's workflow selector): its prompt (BP3 core and `# Tool Use`) and
+   * tool/delegation surface are rebuilt now for `workflowId` with the current
+   * orchestration mode and agents, so its next turn runs on them, and that
+   * turn carries a one-time notice (manager/workflow-switch-notice.mjs). The
+   * provider prompt cache is rebuilt once. Refused while a turn runs, like a
+   * working-folder change. The configured workflow (the default for new
+   * sessions) is the caller's and stays as it is.
+   *
+   * Running work is untouched: agents and workers the session started under
+   * the old workflow are separate sessions with their own prompts and tools,
+   * so they keep running as they are (unlike a working-folder change, running
+   * agents never refuse this); only delegation made from the next turn on
+   * uses the new surface.
+   *
+   * Returns null when the session has no conversation (the caller applies the
+   * configured workflow to an empty session as before), else
+   * `{ appliedToCurrentSession: true, workflow, workflowSwitch }` where
+   * `workflowSwitch` is the transcript boundary (null when unchanged).
+   */
+  async function switchSessionWorkflow(workflowId) {
+    const session = getSession?.();
+    if (!session?.id) return null;
+    const conversation = () =>
+      sessionHasConversationMessages(session) || sessionHasConversationMessages({ messages: session.liveTurnMessages });
+    if (!conversation()) return null;
+    if (isAgentOwner(session) || sessionModeOf(session) === AGENT_MODE) {
+      throw new Error('Only a coding session has a workflow.');
+    }
+    const identity = session.promptIdentity;
+    if (!identity) throw new Error('This session is too old to switch its workflow; start a new task.');
+    const busy = () => getSession?.() !== session || turnInFlight(session);
+    if (busy()) throw new Error(WORKFLOW_SWITCH_BUSY);
+    const config = getConfig();
+    const staged = await stagePolicy(
+      session,
+      identity,
+      { ...config, workflow: { ...(config?.workflow || {}), active: workflowId } },
+      { conversation: true }
+    );
+    if (busy()) throw new Error(WORKFLOW_SWITCH_BUSY);
+    const before = session.workflow;
+    const from = before?.id ? before : null;
+    applyPolicy(session, staged);
+    rewriteConversationBp3Core(session, staged.core);
+    // The request prefix changed: drop provider replay state and the context
+    // baseline, and tag the next send's expected cache break.
+    markToolSurfaceMigrated(session, 'workflow_switch');
+    stageWorkflowSwitchNotice(session, from, session.workflow);
+    let workflowSwitch = null;
+    if (from?.id !== session.workflow.id) {
+      workflowSwitch = {
+        fromId: from?.id || '',
+        from: from?.name || from?.id || '',
+        toId: session.workflow.id,
+        to: session.workflow.name,
+        at: Date.now(),
+      };
+      recordTranscriptBoundary(session, 'workflowSwitches', workflowSwitch, (entry) => entry?.at === workflowSwitch.at);
+    }
+    return { appliedToCurrentSession: true, workflow: session.workflow, workflowSwitch };
+  }
+
+  // An agent profile edit that met a running turn: the next turn applies it.
+  let agentProfilePending = false;
+
+  /**
+   * Bring a Lead session's prompt to the saved bots — its own agent's
+   * persona, AGENT.md and name, and the bot roster its catalogs list — after
+   * a bot was saved, created, renamed, archived or restored
+   * (agent-profile-changes.mjs), on resume, or at the start of the turn after
+   * one that ran through the change (`trigger`: 'save' | 'resume' | 'turn').
+   * Two stamps (agentProfileRevision, agentRosterRevision) tell whether
+   * anything it embeds changed; a delegated worker keeps its prompt. The core
+   * is rebuilt like a workflow switch's (the session's own workflow, the
+   * workspace slices the model was told) and replaces the stored one, so the
+   * next turn sends it with one provider cache break; nothing is re-read per
+   * turn. Tools are untouched. Returns true when the prompt changed.
+   */
+  async function refreshAgentProfile({ trigger = 'save' } = {}) {
+    const session = getSession?.();
+    const identity = session?.promptIdentity;
+    const agent = identity?.agent;
+    if (!session?.id || !agent || isAgentOwner(session)) return false;
+    const revision = agentProfileRevision(agent);
+    const config = getConfig();
+    const workflowId = session.workflow?.id;
+    const workflowConfig = workflowId
+      ? { ...config, workflow: { ...(config?.workflow || {}), active: workflowId } }
+      : config;
+    const roster = leadRosterRevision(
+      leadPartsFor(session, activeWorkflowContext(workflowConfig, getDataDir()).leadPromptParts)
+    );
+    if (session.agentProfileRevision === revision && session.agentRosterRevision === roster) return false;
+    // A coding session from before profile stamps keeps its prompt when it
+    // is reopened; a saved edit still reaches it.
+    if (session.agentProfileRevision === undefined && trigger === 'resume' && sessionModeOf(session) !== AGENT_MODE) {
+      return false;
+    }
+    // At a turn's start its own turn is the one counted; nothing runs yet.
+    const busy = () => getSession?.() !== session || (trigger !== 'turn' && turnInFlight(session));
+    if (busy()) {
+      agentProfilePending = true;
+      return false;
+    }
+    const staged = await stagePolicy(session, identity, workflowConfig, { conversation: true });
+    if (busy()) {
+      agentProfilePending = true;
+      return false;
+    }
+    session.agentProfileRevision = revision;
+    session.agentRosterRevision = roster;
+    session.updatedAt = Date.now();
+    if (staged.core === presentedBp3Core(session)) return false;
+    rewriteConversationBp3Core(session, staged.core);
+    // The request prefix changed: one cache break, tagged on the next send.
+    markToolSurfaceMigrated(session, AGENT_PROFILE_INTENT);
+    return true;
+  }
+
+  /** Turn start: apply an edit that arrived while the previous turn ran. */
+  async function applyPendingAgentProfile() {
+    if (!agentProfilePending) return false;
+    agentProfilePending = false;
+    return refreshAgentProfile({ trigger: 'turn' });
+  }
+
+  return { refreshEmptySessionToolPolicy, switchSessionWorkflow, refreshAgentProfile, applyPendingAgentProfile };
 }

package/src/session-runtime/turn/session-ops.mjs

@@ -29,15 +29,22 @@ export function createSessionOps(deps) {
     } catch {}
   }
 
+  // `rebuildPrompt` (an agent chat's "대화 초기화"): refused while a turn
+  // runs, and the emptied session's prompt and tool surface are then rebuilt
+  // from the current rules, as a new session's are (refreshEmptySessionToolPolicy).
   async function clear(options = {}) {
     const session = getSession();
     if (!session?.id) return false;
+    const rebuild = options.rebuildPrompt === true;
+    if (rebuild && getActiveTurnCount() > 0) throw new Error('The session is running a turn; wait for it to finish.');
     const cleared = await mgr.clearSessionMessages(session.id, options);
     if (!cleared) return false;
     setSession(typeof cleared === 'object' ? cleared : mgr.getSession(session.id) || session);
     if (options.recoverAgent === true) recoverAgentWorkers();
+    let promptRebuilt = false;
+    if (rebuild) promptRebuilt = (await refreshEmptySessionToolPolicy?.())?.appliedToCurrentSession === true;
     invalidateContextStatusCache();
-    return true;
+    return rebuild ? { promptRebuilt } : true;
   }
 
   // Message-selector rewind: drop the chosen user prompt and everything

package/src/session-runtime/turn/turn-run/ask-callbacks.mjs

@@ -61,11 +61,17 @@ export function createAskCallbacks({ transcript, notifyFnForSession, scheduleSea
 
   // The turn's change-record key rides the caller's transcript metadata (in
   // place: the stream stamps assistantAt on this same object), so the
-  // persisted user row and completion carry it across restore.
+  // persisted user row and completion carry it across restore. A merged
+  // batch also names every submission it delivers, so a queued-input restore
+  // can tell each one delivered.
   function stampCheckpoint(options) {
     const meta = options.transcriptMeta;
+    if (!meta || typeof meta !== 'object') return meta;
     const checkpointId = String(options.id || '').trim();
-    if (checkpointId && meta && typeof meta === 'object') meta.checkpointId = checkpointId;
+    if (checkpointId) meta.checkpointId = checkpointId;
+    if (Array.isArray(options.submissionIds) && options.submissionIds.length > 1) {
+      meta.submissionIds = options.submissionIds.map(String);
+    }
     return meta;
   }
 
@@ -74,6 +80,8 @@ export function createAskCallbacks({ transcript, notifyFnForSession, scheduleSea
       beforeToolExecution: () => turn.snapshot.promise || Promise.resolve(),
       transcriptMeta: stampCheckpoint(options),
       promptSource: options.promptSource,
+      // A routine turn's trusted selection text (its instructions only).
+      ...(typeof options.skillSelection === 'string' ? { skillSelection: options.skillSelection } : {}),
       retryFailedTurn: options.retryFailedTurn === true,
       retryTurnId: options.retryTurnId,
       retryAttemptId: options.retryAttemptId,

package/src/session-runtime/turn/turn-run/turn-prepare.mjs

@@ -24,6 +24,7 @@ export function createTurnPreparation({
   prepareTurnWorkspace,
   admitTurnWorkspace,
   applyPendingRoute,
+  applyPendingAgentProfile,
 }) {
   const scopedMcpTools = (session) => scopedMcpToolsFor(session, getConfig());
 
@@ -131,6 +132,8 @@ export function createTurnPreparation({
       assertSessionAdmission?.();
     }
     const modelSwitch = applyPendingRoute?.();
+    // An agent profile saved while the previous turn ran applies from this one.
+    await applyPendingAgentProfile?.();
     options.onRouteApplied?.(getSession());
     if (modelSwitch) options.onModelSwitch?.(modelSwitch);
     ensureSessionTranscriptWriter?.();

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

@@ -1,83 +1,65 @@
 /**
- * Run an inbound webhook as a VISIBLE Mixdog session (schedules parity, user
- * decision): no Lead-context injection, no channel forward — every fire is a
- * fresh New task with the endpoint's prompt/model/workflow/project, owned by
- * 'user' + sourceType 'webhook' (sidebar Automations section, newest per
- * name). Invoked from the channels worker's webhook dispatch.
+ * Run an inbound webhook: the endpoint's instructions and the fenced event
+ * payload become one turn in its owner bot's home thread
+ * (routine-home-turn.mjs). Invoked from the channels worker's webhook
+ * dispatch and the app's "Run now".
  */
-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';
+import { markEndpointRun } from '../runtime/channels/lib/webhooks-db.mjs';
+import { runOwnedAutomation } from './owned-automation-run.mjs';
+import { runRoutineTurn } from './routine-home-turn.mjs';
 
-/** Endpoint model ref wins; the maintenance.webhook route is the fallback. */
-function webhookRoute(modelRef) {
-  if (modelRef) {
-    const ref = parseScheduleModelRef(modelRef);
-    // A model the provider catalog superseded runs on its successor.
-    if (ref && typeof ref === 'object') return migrateCodexRoute(ref);
+/**
+ * One run of the endpoint in its owner's thread (Mixy when absent): a run
+ * while the previous one of the same endpoint is still going is skipped (and
+ * stamped), and every outcome is stamped on the endpoint. `prompt` carries the
+ * fenced payload; `skillSelection` only the endpoint's instructions.
+ */
+export async function runWebhookSession({ ownerAgentId = null, ...options }, deps = {}) {
+  const name = String(options.name || '').trim();
+  const { markRun = markEndpointRun, run = runWebhookTurn, ...ownedDeps } = deps;
+  const stamp = (outcome) =>
+    markRun(name, outcome, new Date()).catch((error) =>
+      process.stderr.write(`mixdog webhook: ${name} ${outcome} stamp failed: ${error?.message || error}\n`)
+    );
+  let outcome;
+  try {
+    // The dispatch's cancellation reaches the run as `signal`.
+    outcome = await runOwnedAutomation(
+      'webhook',
+      { name, ownerAgentId },
+      ({ signal }) => run({ ...options, ownerAgentId, signal }),
+      { recordSkip: () => stamp('skipped'), signal: options.signal || null, ...ownedDeps }
+    );
+  } catch (error) {
+    await stamp('failed');
+    throw error;
   }
-  const cfg = loadConfig({ secrets: false });
-  const maintenance = cfg?.maintenance?.webhook;
-  if (maintenance?.provider && maintenance?.model) return modelRouteFields(maintenance);
-  throw new Error('webhook run has no model: set one on the endpoint or configure maintenance.webhook');
+  if (!outcome.skipped) await stamp('success');
+  return outcome;
 }
 
-export async function runWebhookSession({
+/** One turn in the owner's thread; `skillSelection` absent selects nothing. */
+function runWebhookTurn({
   name,
-  model = null,
   prompt,
+  ownerAgentId = null,
   cwd = null,
-  workflow = null,
   attachments = null,
-  signal = null,
-  // Endpoint-authored instructions: the run's ONLY skill-selection input.
-  // `prompt` also carries the fenced external payload, which must never
-  // select a skill; absent means nothing selects.
+  event = '',
   skillSelection = '',
+  signal = null,
 }) {
   const endpoint = String(name || '').trim();
-  const body = String(prompt || '').trim();
   if (!endpoint) throw new Error('runWebhookSession: endpoint name required');
-  if (!body) throw new Error(`webhook "${endpoint}" has no prompt body`);
-  // The dispatcher's cancellation (delivery timeout) has to reach the run
-  // itself: an already-cancelled dispatch must not even create a session.
-  if (signal?.aborted) throw signal.reason ?? new Error('webhook dispatch aborted');
-  const route = webhookRoute(model);
-  const projectCwd = cwd ? String(cwd) : null;
-  const session = createSession({
-    ...modelRouteFields(route),
-    owner: 'user',
-    sourceType: 'webhook',
-    sourceName: endpoint,
-    ...(projectCwd ? { cwd: projectCwd } : {}),
-    desktopSession: projectCwd
-      ? { classification: 'project', projectPath: projectCwd }
-      : { classification: 'task', projectPath: null },
-    ...automationWorkflowOpts(workflow),
+  return runRoutineTurn({
+    kind: 'webhook',
+    name: endpoint,
+    ownerAgentId,
+    prompt,
+    skillSelection: String(skillSelection ?? ''),
+    attachments,
+    cwd,
+    event,
+    signal,
   });
-  // The user message leads with the endpoint's instructions, so Recent titles
-  // read as the user-authored intent rather than payload noise.
-  // Stored attachments ride along as composer-style content parts.
-  const content = automationPromptContent(body, attachments);
-  // askOpts.signal is the parent-abort link: it is cascaded onto the turn
-  // controller, so aborting it stops the in-flight provider/tool work instead
-  // of leaving a timed-out delivery's session running with live side effects.
-  const ask = (turnContent, askOpts) =>
-    askSession(session.id, turnContent, null, null, projectCwd || undefined, undefined, {
-      ...askOpts,
-      ...(signal ? { signal } : {}),
-    });
-  // Agents the run delegates to report back; each result is the next turn
-  // (runAutomationTurns marks those turns as task notifications).
-  const result = await runAutomationTurns(
-    session.id,
-    () => ask(content, { skillSelection: String(skillSelection ?? '') }),
-    ask
-  );
-  return { sessionId: session.id, result: String(result?.content || '') };
 }