mixdog 1.2.6 → 1.3.1

package/src/runtime/agent/orchestrator/tools/lib/shell-run-state.mjs

@@ -104,6 +104,9 @@ export function createShellRun({ abortSignal, resolve, jobId = null }) {
     // `settled`: whichever transition wins first wins for good.
     autoBackgrounded: false,
     autoBackgroundJobId: null,
+    // [exitCode, signal] of a 'close' that arrived while promotion was in
+    // flight; a promotion that then fails settles the run with it.
+    promotionClose: null,
     autoBgTimer: null,
     killUnconfirmed: false,
     child: null,

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -288,6 +288,7 @@ async function settleQueuedPromotion(jobId) {
 function queueSaturatedAsTask(run, saturation, spec) {
   const queuedAbort = new AbortController();
   const taskId = run.foregroundRecordId;
+  let promotedJobId = null;
   let task;
   try {
     task = startBackgroundTask({
@@ -301,10 +302,15 @@ function queueSaturatedAsTask(run, saturation, spec) {
       input: { command: spec.command, cwd: spec.cwd },
       meta: { task_id: taskId, stdout: null, stderr: null, cwd: spec.cwd, timeoutMs: spec.backgroundDeadlineMs || 0 },
       resultType: 'shell_task_result',
+      // While the command runs in the foreground, its abort handler snapshots
+      // the tree before it kills. A native kill sent here as well would end
+      // the root first: the snapshot then misses the tree and the workspace
+      // stays held as unconfirmed forever. Only a promoted job is killed here.
       cancel: () => {
         queuedAbort.abort();
+        if (!promotedJobId) return;
         try {
-          killShellJob(taskId);
+          killShellJob(promotedJobId);
         } catch {}
       },
       run: async () => {
@@ -319,7 +325,17 @@ function queueSaturatedAsTask(run, saturation, spec) {
           onProgress: null,
           onOutputTail: null,
         });
-        if (result.backgrounded && result.jobId) return settleQueuedPromotion(result.jobId);
+        if (result.backgrounded && result.jobId) {
+          promotedJobId = result.jobId;
+          // Promotion detached the abort handler: a cancel that landed during
+          // the handoff reaches the promoted job here.
+          if (queuedAbort.signal.aborted) {
+            try {
+              killShellJob(promotedJobId);
+            } catch {}
+          }
+          return settleQueuedPromotion(promotedJobId);
+        }
         const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
         if (result.exitCode !== 0) {
           throw new Error(`exit code ${result.exitCode ?? result.signal ?? 'unknown'}${output ? `\n${output}` : ''}`);
@@ -573,65 +589,67 @@ export function execShellCommand(options) {
     // The user approved this call's elevation 'ask' decision (runtime-set).
     elevationApproved = false,
   } = options;
-  return new Promise(async (resolve) => {
+  return new Promise((resolve) => {
     const run = createShellRun({ abortSignal, resolve, jobId });
-    // An async executor's throw is NOT routed to this Promise — it becomes an
-    // unhandled rejection of the executor's own promise while the awaiting
-    // caller hangs forever. Every path below therefore has to settle the run
-    // itself, including the unexpected one.
-    try {
-      const spawned = await admitAndSpawn(
-        run,
-        {
-          admission,
-          shell,
-          shellArg,
-          shellArgs,
+    // A throw inside this async body is NOT routed to the Promise — it becomes
+    // an unhandled rejection while the awaiting caller hangs forever. Every
+    // path below therefore has to settle the run itself, including the
+    // unexpected one.
+    void (async () => {
+      try {
+        const spawned = await admitAndSpawn(
+          run,
+          {
+            admission,
+            shell,
+            shellArg,
+            shellArgs,
+            command,
+            env,
+            cwd,
+            abortSignal,
+            directArgv,
+            execScript,
+            elevationApproved,
+            ownerSessionId,
+            clientHostPid,
+          },
+          {
+            admissionWaitMs,
+            onSaturated: (err) => backgroundOnTimeout && queueSaturatedAsTask(run, err, options),
+          }
+        );
+        if (!spawned) return;
+
+        // Pre-aborted signal: kill immediately if the abort already fired
+        // before spawn returned (synchronous reentry from a parent abort), so
+        // the child doesn't run for the full timeoutMs window.
+        if (abortSignal?.aborted) {
+          treeKillForceSettle(run, 'cancellation');
+        }
+        attachOutputCapture(run);
+        const releasePromotedCapture = createPromotedCaptureRelease(run);
+        run.settle = createSettle(run, releasePromotedCapture);
+        attachChildExit(run, releasePromotedCapture);
+        const fireAutoBackground = createAutoBackground({
+          run,
           command,
-          env,
           cwd,
-          abortSignal,
-          directArgv,
-          execScript,
-          elevationApproved,
-          ownerSessionId,
           clientHostPid,
-        },
-        {
-          admissionWaitMs,
-          onSaturated: (err) => backgroundOnTimeout && queueSaturatedAsTask(run, err, options),
-        }
-      );
-      if (!spawned) return;
-
-      // Pre-aborted signal: kill immediately if the abort already fired
-      // before spawn returned (synchronous reentry from a parent abort), so
-      // the child doesn't run for the full timeoutMs window.
-      if (abortSignal?.aborted) {
-        treeKillForceSettle(run, 'cancellation');
+          ownerSessionId,
+          promotedTimeoutMs,
+          backgroundDeadlineMs,
+        });
+        armDeadlines(
+          run,
+          { timeoutMs, autoBackgroundMs, autoBackgroundReason, backgroundOnTimeout, abortSignal },
+          fireAutoBackground
+        );
+        armInputWake(run, wakeSignal, fireAutoBackground);
+        armProgressTimers(run, { onProgress, onOutputTail });
+      } catch (err) {
+        settleSetupFailure(run, err);
       }
-      attachOutputCapture(run);
-      const releasePromotedCapture = createPromotedCaptureRelease(run);
-      run.settle = createSettle(run, releasePromotedCapture);
-      attachChildExit(run, releasePromotedCapture);
-      const fireAutoBackground = createAutoBackground({
-        run,
-        command,
-        cwd,
-        clientHostPid,
-        ownerSessionId,
-        promotedTimeoutMs,
-        backgroundDeadlineMs,
-      });
-      armDeadlines(
-        run,
-        { timeoutMs, autoBackgroundMs, autoBackgroundReason, backgroundOnTimeout, abortSignal },
-        fireAutoBackground
-      );
-      armInputWake(run, wakeSignal, fireAutoBackground);
-      armProgressTimers(run, { onProgress, onOutputTail });
-    } catch (err) {
-      settleSetupFailure(run, err);
-    }
+    })();
   });
 }

package/src/runtime/attachments/store.mjs

@@ -166,6 +166,12 @@ function saveBuffer(buffer) {
   return { attachmentRef, sizeBytes: buffer.length };
 }
 
+/** Store `buffer` (a file a bot or agent hands on, session-runtime/
+ *  handoff-attachments.mjs) under its content address: `{ attachmentRef, sizeBytes }`. */
+export function storeAttachmentBuffer(buffer) {
+  return saveBuffer(buffer);
+}
+
 export function isAttachmentReference(value) {
   return Boolean(value && typeof value === 'object' && ATTACHMENT_REF_RE.test(String(value.attachmentRef || '')));
 }

package/src/runtime/browser-bridge/client.mjs

@@ -53,6 +53,30 @@ export async function finishBrowserTurn(sessionId, turnId, { aborted = false } =
   }
 }
 
+/** Runtime-only: fill the secret the user handed the desktop for `requestId`
+ *  into the page's focused password field through the host's isolated-world
+ *  fill. The value never passes through here; the host answers only
+ *  'provided' or 'skipped'. */
+export async function browserSecretInput(sessionId, requestId, { signal } = {}) {
+  const discovery = readBridgeDiscovery(DISCOVERY_FILE);
+  if (!discovery || !sessionId || !requestId) return 'skipped';
+  try {
+    const result = await requestBridge(
+      discovery,
+      JSON.stringify({ action: 'secret_input', session_id: String(sessionId), request_id: String(requestId) }),
+      signal
+        ? AbortSignal.any([AbortSignal.timeout(REQUEST_TIMEOUT_MS), signal])
+        : AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      { sessionId, action: 'secret_input' }
+    );
+    return result.status === 200 && result.body?.ok !== false && result.body?.value?.text === 'provided'
+      ? 'provided'
+      : 'skipped';
+  } catch {
+    return 'skipped';
+  }
+}
+
 const BRIDGE_UNAVAILABLE_MESSAGE = 'browser use is unavailable; open the Mixdog desktop app and enable Browser Use';
 
 /** Sync gate for the session tool surface (featureDisallowedTools). */

package/src/runtime/channels/lib/scheduler.mjs

@@ -12,6 +12,7 @@ import {
   markFired,
   markDone,
   markScheduleFailure,
+  markScheduleSkipped,
   markScheduleSuccess,
   setDeferred,
   setNextFire,
@@ -61,6 +62,11 @@ function isCronExpression(time) {
     return false;
   }
 }
+// True when this fire (started at `since`) ended in an overlap skip.
+function skippedSince(schedule, since) {
+  const at = schedule.lastSkippedAt ? new Date(schedule.lastSkippedAt).getTime() : 0;
+  return at >= since.getTime();
+}
 // Records a one-shot fire that did not complete; the entry stays pending.
 async function markOneShotFailed(schedule) {
   schedule.lastFailedAt = new Date().toISOString();
@@ -407,6 +413,8 @@ ${prompt}`;
       schedule.lastFiredAt = startedAt.toISOString();
       this.lastFired.set(schedule.name, startedAt.toISOString());
       const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
+      // An overlap skip is recorded as a skip, never as a failed run.
+      if (!fired && skippedSince(schedule, startedAt)) return;
       if (!fired) {
         schedule.lastFailedAt = new Date().toISOString();
         await markScheduleFailure(schedule.name, new Date());
@@ -498,7 +506,7 @@ ${prompt}`;
       return;
     }
     // Mark done ONLY after a successful fire. A false/throwing fireTimed
-    // (missing prompt/model, running guard, dispatch error) must leave the
+    // (missing prompt, running guard, paused owner, dispatch error) must leave the
     // one-shot pending so a reload/restart can retry it — never retire it.
     try {
       // awaitDispatch: for a one-shot we must wait for the actual LLM/relay
@@ -506,6 +514,10 @@ ${prompt}`;
       // contract) would retire the entry even when schedulerLlm() later
       // rejects. Only a resolved dispatch counts as a real fire here.
       const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
+      if (!fired && skippedSince(schedule, now)) {
+        logSchedule(`one-shot "${schedule.name}" skipped (previous run in progress) — leaving pending for retry\n`);
+        return;
+      }
       if (!fired) {
         await markOneShotFailed(schedule);
         logSchedule(`one-shot "${schedule.name}" did not fire (skipped/guarded) — leaving pending for retry\n`);
@@ -625,20 +637,11 @@ ${prompt}`;
   async fireTimedPrompt(schedule, type, prompt, { awaitDispatch = false } = {}) {
     logSchedule(`firing ${schedule.name} (${type})\n`);
     if (this.running.has(schedule.name)) {
-      // Not silent anymore: overlap skips were invisible and read as the
-      // scheduler "ignoring" a fire.
-      logSchedule(`${schedule.name}: skipped — previous run still in progress\n`);
+      this.recordSkip(schedule);
       return false;
     }
     if (type === 'interactive' && this.injectIntoLead(schedule, type, prompt)) return true;
     this.running.add(schedule.name);
-    const presetId = schedule.model;
-    if (!presetId) {
-      this.running.delete(schedule.name);
-      logSchedule(`${schedule.name}: missing required "model" in schedule config — dispatch rejected\n`);
-      this.notifyFailure(schedule, 'missing "model" in schedule config — dispatch rejected');
-      return false;
-    }
     // Cron (recurring) keeps the fire-and-forget contract: return truthy now
     // and swallow async failures. A one-shot (awaitDispatch) instead awaits
     // the dispatch so a rejected run propagates and the caller leaves the
@@ -676,8 +679,22 @@ ${prompt}`;
       ? this.scheduleRunner(schedule, { prompt })
       : Promise.reject(new Error('schedule runner not configured'));
     return run
-      .then(({ result }) => {
+      .then((outcome) => {
         this.running.delete(schedule.name);
+        // The run path found this schedule's previous run still going (a
+        // "run now" from the app) or backing off after failures in a row; it
+        // already persisted the skip.
+        if (outcome?.skipped) {
+          schedule.lastSkippedAt = new Date().toISOString();
+          const why =
+            outcome.reason === 'backoff'
+              ? 'backing off after failures'
+              : outcome.reason === 'owner'
+                ? `paused: ${outcome.message}`
+                : 'previous run still in progress';
+          logSchedule(`${schedule.name}: skipped — ${why}\n`);
+          return false;
+        }
         logSchedule(`${schedule.name} done\n`);
         return true;
       })
@@ -693,6 +710,17 @@ ${prompt}`;
       });
   }
   // ── Helpers ─────────────────────────────────────────────────────────
+  /** Overlap skip: the previous run of this schedule is still in progress.
+   *  Logged and persisted (last_skipped_at) so a skipped fire is never
+   *  invisible; `persistSkip` is injectable for tests. */
+  recordSkip(schedule) {
+    const at = new Date();
+    schedule.lastSkippedAt = at.toISOString();
+    logSchedule(`${schedule.name}: skipped — previous run still in progress\n`);
+    void Promise.resolve()
+      .then(() => (this.persistSkip ?? markScheduleSkipped)(schedule.name, at))
+      .catch((err) => process.stderr.write(`mixdog scheduler: ${schedule.name} skip record failed: ${err}\n`));
+  }
   /** Failure notice: logged so scheduled fires never fail silently. */
   notifyFailure(schedule, reason) {
     logSchedule(`schedule "${schedule?.name}": ${reason}\n`);

package/src/runtime/channels/lib/schedules-db.mjs

@@ -14,6 +14,7 @@
 import { ensurePgInstance, withSchemaBootstrapLock } from '../../memory/lib/pg/adapter.mjs';
 import { createPgSchemaDb } from '../../shared/pg-schema-db.mjs';
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
+import { ROUTINE_LIMITS } from '../../shared/routine-limits.mjs';
 
 const SCHEMA = 'scheduler';
 
@@ -54,6 +55,18 @@ ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS last_scheduled_at times
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS last_started_at timestamptz;
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS last_success_at timestamptz;
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS last_failed_at timestamptz;
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS last_skipped_at timestamptz;
+-- The agent a schedule belongs to (its results land in that agent's home
+-- thread). Rows from before ownership existed fill with Mixy ('lead').
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS owner_agent_id text NOT NULL DEFAULT 'lead';
+-- Legacy columns model, workflow and run_as_agent are no longer read or written (kept, not dropped, to avoid a risky migration).
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS run_as_agent boolean NOT NULL DEFAULT false;
+-- Failed runs in a row: a success or switching it back on resets it; at
+-- ROUTINE_LIMITS.pauseAfterFailures the schedule switches itself off.
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS consecutive_failures integer NOT NULL DEFAULT 0;
+-- Results of finished runs not yet queued for the owner's home thread, by run
+-- id ({ state: 'pending' | 'failed', error?, at, result }).
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS result_delivery jsonb;
 `;
 
 const getDb = createPgSchemaDb({
@@ -78,9 +91,7 @@ function rowToDef(row) {
     timezone: row.timezone,
     target: row.target,
     channelId: row.channel_id,
-    model: row.model,
     cwd: row.cwd,
-    workflow: row.workflow,
     attachments: row.attachments || null,
     delivery: row.delivery || null,
     prompt: row.prompt,
@@ -91,6 +102,10 @@ function rowToDef(row) {
     lastStartedAt: row.last_started_at,
     lastSuccessAt: row.last_success_at,
     lastFailedAt: row.last_failed_at,
+    lastSkippedAt: row.last_skipped_at,
+    ownerAgentId: row.owner_agent_id || 'lead',
+    consecutiveFailures: Number(row.consecutive_failures) || 0,
+    resultDelivery: row.result_delivery || null,
     nextFireAt: row.next_fire_at,
     deferredUntil: row.deferred_until,
     skippedUntil: row.skipped_until,
@@ -100,7 +115,7 @@ function rowToDef(row) {
 }
 
 const COLS =
-  'name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, workflow, attachments, delivery, prompt, enabled, status, last_fired_at, last_scheduled_at, last_started_at, last_success_at, last_failed_at, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
+  'name, description, when_at, when_cron, timezone, target, channel_id, cwd, attachments, delivery, prompt, enabled, status, last_fired_at, last_scheduled_at, last_started_at, last_success_at, last_failed_at, last_skipped_at, owner_agent_id, consecutive_failures, result_delivery, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -134,30 +149,28 @@ export async function upsertSchedule(def, { dataDir } = {}) {
     def.timezone ?? null,
     def.target,
     def.channelId ?? null,
-    def.model ?? null,
     def.cwd ?? null,
-    def.workflow ?? null,
     def.attachments ? JSON.stringify(def.attachments) : null,
     def.delivery ?? null,
     def.prompt,
     def.enabled ?? true,
     def.status ?? 'active',
     def.nextFireAt ?? null,
+    def.ownerAgentId || 'lead',
   ];
   const { rows } = await db.query(
     `INSERT INTO scheduler.schedules
-       (name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, workflow, attachments, delivery, prompt, enabled, status, next_fire_at)
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)
+       (name, description, when_at, when_cron, timezone, target, channel_id, cwd, attachments, delivery, prompt, enabled, status, next_fire_at, owner_agent_id)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
      ON CONFLICT (name) DO UPDATE SET
+       owner_agent_id = EXCLUDED.owner_agent_id,
        description  = EXCLUDED.description,
        when_at      = EXCLUDED.when_at,
        when_cron    = EXCLUDED.when_cron,
        timezone     = EXCLUDED.timezone,
        target       = EXCLUDED.target,
        channel_id   = EXCLUDED.channel_id,
-       model        = EXCLUDED.model,
        cwd          = EXCLUDED.cwd,
-       workflow     = EXCLUDED.workflow,
        attachments  = EXCLUDED.attachments,
        delivery     = EXCLUDED.delivery,
        prompt       = EXCLUDED.prompt,
@@ -173,6 +186,8 @@ export async function upsertSchedule(def, { dataDir } = {}) {
        last_started_at = NULL,
        last_success_at = NULL,
        last_failed_at = NULL,
+       last_skipped_at = NULL,
+       consecutive_failures = 0,
        updated_at   = now()
      RETURNING ${COLS}`,
     params
@@ -198,8 +213,16 @@ async function updateScheduleColumn(name, column, value, dataDir) {
   return rowToDef(rows[0]);
 }
 
+/** Switching a schedule back on clears its failure streak. */
 export async function setEnabled(name, enabled, { dataDir } = {}) {
-  return updateScheduleColumn(name, 'enabled', !!enabled, dataDir);
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules
+        SET enabled = $2, consecutive_failures = CASE WHEN $2 THEN 0 ELSE consecutive_failures END, updated_at = now()
+      WHERE name = $1 RETURNING ${COLS}`,
+    [name, !!enabled]
+  );
+  return rowToDef(rows[0]);
 }
 
 export async function markFired(name, ts = new Date(), { dataDir } = {}) {
@@ -240,11 +263,47 @@ export async function claimScheduleRun(name, scheduledAt, startedAt, nextFireAt,
 }
 
 export async function markScheduleSuccess(name, ts = new Date(), { dataDir } = {}) {
-  return updateScheduleColumn(name, 'last_success_at', ts, dataDir);
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules SET last_success_at = $2, consecutive_failures = 0, updated_at = now()
+      WHERE name = $1 RETURNING ${COLS}`,
+    [name, ts]
+  );
+  return rowToDef(rows[0]);
 }
 
+/** One more failure in a row; the one reaching the pause limit switches the
+ *  schedule off (claimScheduleRun admits only enabled rows). */
 export async function markScheduleFailure(name, ts = new Date(), { dataDir } = {}) {
-  return updateScheduleColumn(name, 'last_failed_at', ts, dataDir);
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules
+        SET last_failed_at = $2, consecutive_failures = consecutive_failures + 1,
+            enabled = enabled AND consecutive_failures + 1 < $3, updated_at = now()
+      WHERE name = $1 RETURNING ${COLS}`,
+    [name, ts, ROUTINE_LIMITS.pauseAfterFailures]
+  );
+  return rowToDef(rows[0]);
+}
+
+/** Set (`entry`) or clear (null) the undelivered result of run `runId`. */
+export async function recordScheduleDelivery(name, runId, entry, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  await db.query(
+    entry
+      ? `UPDATE scheduler.schedules
+            SET result_delivery = COALESCE(result_delivery, '{}'::jsonb) || jsonb_build_object($2::text, $3::jsonb)
+          WHERE name = $1`
+      : `UPDATE scheduler.schedules
+            SET result_delivery = NULLIF(COALESCE(result_delivery, '{}'::jsonb) - $2::text, '{}'::jsonb)
+          WHERE name = $1`,
+    entry ? [name, runId, JSON.stringify(entry)] : [name, runId]
+  );
+}
+
+/** A fire skipped because the previous run of the same schedule still runs. */
+export async function markScheduleSkipped(name, ts = new Date(), { dataDir } = {}) {
+  return updateScheduleColumn(name, 'last_skipped_at', ts, dataDir);
 }
 
 export async function markDone(name, { dataDir } = {}) {

package/src/runtime/channels/lib/webhook/session-dispatch.mjs

@@ -1,9 +1,14 @@
 import { logWebhook } from './log.mjs';
-import { updateDeliveryStatus } from '../webhooks-db.mjs';
+import { recordEndpointEvent, updateDeliveryStatus } from '../webhooks-db.mjs';
 import { UNTRUSTED_MARKER, scrubFenceMarker } from './untrusted-fence.mjs';
 
 const DISPATCH_TIMEOUT_MS = 10 * 60 * 1000;
 
+/** The headers a run's prompt shows (and a stored event keeps). */
+function promptHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers || {}).filter(([k]) => k.startsWith('x-') || k === 'content-type'));
+}
+
 function buildFencedPayload(body, headers) {
   // Trust boundary: webhook body + headers are external input and must be
   // treated as DATA, never instructions. The directive line gives the
@@ -11,8 +16,7 @@ function buildFencedPayload(body, headers) {
   const _UNTRUSTED = UNTRUSTED_MARKER;
   const payload = scrubFenceMarker(JSON.stringify(body, null, 2));
   const headersSummary = scrubFenceMarker(
-    Object.entries(headers)
-      .filter(([k]) => k.startsWith('x-') || k === 'content-type')
+    Object.entries(promptHeaders(headers))
       .map(([k, v]) => `${k}: ${v}`)
       .join('\n')
   );
@@ -35,6 +39,14 @@ function webhookRunPrompt(instructions, body, headers) {
   return { prompt: `${trusted}\n\n${buildFencedPayload(body, headers)}`, skillSelection: trusted };
 }
 
+/** A short label of the event for the routine marker in the bot's chat
+ *  (display only, never model-visible): the sender's event type and action. */
+function webhookEventSummary(headers, body) {
+  const field = (value) => (typeof value === 'string' ? value.trim() : '');
+  const type = field(headers?.['x-github-event']) || field(headers?.['sentry-hook-resource']) || field(body?.type);
+  return [type, field(body?.action)].filter(Boolean).join(' · ').slice(0, 120);
+}
+
 function trackDispatch({ name, deliveryId, dispatchP, controller }) {
   let settled = false;
   const timeoutHandle = setTimeout(
@@ -63,7 +75,10 @@ function trackDispatch({ name, deliveryId, dispatchP, controller }) {
     { once: true }
   );
   dispatchP.then(
-    () => finish('done', {}, `${name}: webhook session run dispatched (id=${deliveryId})`),
+    (run) =>
+      run?.skipped
+        ? finish('skipped', {}, `${name}: previous run still in progress; skipped (id=${deliveryId})`)
+        : finish('done', {}, `${name}: webhook session run dispatched (id=${deliveryId})`),
     (err) =>
       finish(
         'failed',
@@ -73,8 +88,8 @@ function trackDispatch({ name, deliveryId, dispatchP, controller }) {
   );
 }
 
-function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
-  async function dispatchSessionRun(name, model, fullPrompt, headers, deliveryId, res, extra = {}) {
+function createWebhookSessionDispatcher({ getBridgeDispatch }) {
+  async function dispatchSessionRun(name, fullPrompt, deliveryId, res, extra = {}) {
     await updateDeliveryStatus(name, deliveryId, 'processing');
     // Session dispatch must not be allowed to hang forever — without a
     // ceiling a stuck LLM call leaves the delivery in `processing`
@@ -88,13 +103,10 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
     const controller = new AbortController();
     const dispatchP = Promise.resolve(
       getBridgeDispatch()({
-        model: model || null,
         prompt: fullPrompt,
         signal: controller.signal,
-        // Endpoint-scoped project/workflow (New-task parity): the webhook row's
-        // cwd/workflow define the created session, not the worker's global cwd.
-        cwd: extra.cwd || getConfig()?.cwd || null,
-        workflow: extra.workflow || null,
+        // The endpoint's project folder, named to the bot in the turn.
+        cwd: extra.cwd || null,
         attachments: extra.attachments || null,
         delivery: extra.delivery || null,
         // Trusted skill-selection input: only the endpoint-authored
@@ -104,8 +116,10 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
         context: {
           source: 'webhook',
           endpoint: name,
+          // The bot whose chat the run is a turn in.
+          owner: extra.owner || null,
           deliveryId,
-          event: headers['x-github-event'] || null,
+          event: extra.event || null,
         },
       })
     );
@@ -116,12 +130,18 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
 
   async function dispatchEndpoint({ name, body, headers, res, deliveryId, endpoint }) {
     try {
-      const { model, instructions, cwd, workflow, attachments, delivery } = endpoint;
+      const { instructions, cwd, attachments, delivery, ownerAgentId } = endpoint;
       const run = webhookRunPrompt(instructions, body, headers);
       if (!getBridgeDispatch()) throw new Error(`[webhook] session dispatch requires bridgeDispatch`);
-      await dispatchSessionRun(name, model || null, run.prompt, headers, deliveryId, res, {
+      // Kept for the app's "Run now", which re-runs the latest event. Losing
+      // the record never blocks the delivery itself.
+      await recordEndpointEvent(name, { body, headers: promptHeaders(headers) }).catch((e) =>
+        logWebhook(`${name}: event record failed: ${e?.message || e}`)
+      );
+      await dispatchSessionRun(name, run.prompt, deliveryId, res, {
+        owner: ownerAgentId || null,
         cwd: cwd || null,
-        workflow: workflow || null,
+        event: webhookEventSummary(headers, body),
         attachments: attachments || null,
         delivery: delivery || null,
         skillSelection: run.skillSelection,
@@ -137,4 +157,4 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
   return { dispatchEndpoint };
 }
 
-export { buildFencedPayload, createWebhookSessionDispatcher, webhookRunPrompt };
+export { buildFencedPayload, createWebhookSessionDispatcher, promptHeaders, webhookEventSummary, webhookRunPrompt };

package/src/runtime/channels/lib/webhook.mjs

@@ -23,7 +23,6 @@ class WebhookServer {
       },
     });
     this.sessionDispatcher = createWebhookSessionDispatcher({
-      getConfig: () => this.config,
       getBridgeDispatch: () => this.bridgeDispatch,
     });
     this.requestHandler = createWebhookRequestHandler({