mixdog 1.2.5 → 1.3.0

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

@@ -8,6 +8,8 @@
 // `powershell -Command "<inline>"` / `pwsh -Command "<inline>"` to
 // `-EncodedCommand <utf16le-base64>` so the payload stays opaque to the
 // outer shell. Other shells / non-Windows are no-op pass-through.
+import { codeMask } from './builtin/bash-tool/bashism-rewrite.mjs';
+
 // Match -Command "<body>" where the body may contain escaped quotes
 // (`\"` or `""`). Stops at the first unescaped closing quote so nested
 // patterns like `"... \"inner\" ..."` survive intact. Common PowerShell
@@ -16,49 +18,63 @@
 // Single-quoted -Command '<body>' is also covered.
 const _POWERSHELL_FLAGS_RE =
   /\s+-(?:NoProfile|NonInteractive|WindowStyle\s+\S+|ExecutionPolicy\s+\S+|Sta|Mta|NoLogo|NoExit)/.source;
+// What may follow the closing quote: the end of the command or a shell
+// operator. Anything else (`pwsh -Command "a" "b"`) is more arguments, which
+// PowerShell appends to the command text and an -EncodedCommand would drop.
+const _POWERSHELL_TRAILING = '(?=[ \\t]*(?:$|[\\r\\n;|&<>]|\\d+>))';
 const _POWERSHELL_DOUBLE_RE = new RegExp(
   '\\b(powershell(?:\\.exe)?|pwsh(?:\\.exe)?)((?:' +
     _POWERSHELL_FLAGS_RE +
-    ')*)\\s+(?:-Command|-c)\\s+"((?:[^"\\\\]|\\\\.|"")+?)"(?=\\s|$|;|&&|\\|\\|)',
+    ')*)\\s+(?:-Command|-c)\\s+"((?:[^"\\\\]|\\\\.|"")+?)"' +
+    _POWERSHELL_TRAILING,
   'gi'
 );
 const _POWERSHELL_SINGLE_RE = new RegExp(
   '\\b(powershell(?:\\.exe)?|pwsh(?:\\.exe)?)((?:' +
     _POWERSHELL_FLAGS_RE +
-    ")*)\\s+(?:-Command|-c)\\s+'((?:[^'\\\\]|\\\\.|'')+?)'(?=\\s|$|;|&&|\\|\\|)",
+    ")*)\\s+(?:-Command|-c)\\s+'((?:[^'\\\\]|\\\\.|'')+?)'" +
+    _POWERSHELL_TRAILING,
   'gi'
 );
 
-export function _maybeEncodePowerShellCommand(command) {
-  if (process.platform !== 'win32') return command;
-  if (typeof command !== 'string' || command.length === 0) return command;
-  const replaceFn = (match, exe, flags, body) => {
+// One pass of one quote style. Only an invocation the outer shell itself runs
+// is rewritten: the same text inside a string, here-string or comment (a
+// README being written, a commit message) is data, not a command.
+function _encodePass(command, pattern, quote) {
+  const live = codeMask(command);
+  if (!live) return command;
+  return command.replace(pattern, (match, exe, flags, body, offset) => {
+    if (!live[offset]) return match;
     try {
-      // Unescape doubled-up quotes the caller used to embed " / ' inside
-      // the -Command literal. We're handing the body to powershell as
-      // base64 so the outer-shell escaping is no longer needed.
-      // Unescape both PowerShell-style doubled quotes (`""` / `''`) AND
-      // bash-style backslash-escaped quotes (`\"` / `\'`) since POSIX
-      // outer-shell wrappers commonly use backslash form. Without
-      // backslash unescape, `pwsh -Command "Get-Process \"foo\""` would
-      // base64-encode the literal backslash, breaking inside PowerShell.
-      const unescaped = _unescapePowerShellCommandBody(body);
+      // Unescape the quote the caller used to embed the body: the PowerShell
+      // doubled form (`""` / `''`) AND the bash-style backslash form (`\"` /
+      // `\'`) POSIX outer-shell wrappers commonly use. Without the backslash
+      // unescape, `pwsh -Command "Get-Process \"foo\""` would base64-encode the
+      // literal backslash. The OTHER quote is the body's own syntax and stays.
+      const unescaped = _unescapePowerShellCommandBody(body, quote);
       const encoded = Buffer.from(unescaped, 'utf16le').toString('base64');
       const trimmedFlags = (flags || '').replace(/\s+/g, ' ').trim();
       return `${exe}${trimmedFlags ? ` ${trimmedFlags}` : ''} -EncodedCommand ${encoded}`;
     } catch {
       return match;
     }
-  };
-  return command.replace(_POWERSHELL_DOUBLE_RE, replaceFn).replace(_POWERSHELL_SINGLE_RE, replaceFn);
+  });
+}
+
+export function _maybeEncodePowerShellCommand(command) {
+  if (process.platform !== 'win32') return command;
+  if (typeof command !== 'string' || command.length === 0) return command;
+  return _encodePass(_encodePass(command, _POWERSHELL_DOUBLE_RE, '"'), _POWERSHELL_SINGLE_RE, "'");
 }
 
-function _unescapePowerShellCommandBody(body) {
-  return String(body || '')
-    .replace(/""/g, '"')
-    .replace(/''/g, "'")
-    .replace(/\\"/g, '"')
-    .replace(/\\'/g, "'");
+// `quote` names the delimiter that wrapped the body, so only its own escapes
+// are removed. Without it (policy scanning, which wants every reading of the
+// body) both styles are removed.
+function _unescapePowerShellCommandBody(body, quote) {
+  let text = String(body || '');
+  if (quote !== "'") text = text.replace(/""/g, '"').replace(/\\"/g, '"');
+  if (quote !== '"') text = text.replace(/''/g, "'").replace(/\\'/g, "'");
+  return text;
 }
 
 // Extract inline `powershell -Command "…"` bodies for policy scan parity

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

@@ -126,11 +126,15 @@ function getSnapshotScript(shellPath, snapshotFilePath, configFileExists) {
         declare -f "$func" >> "$SNAPSHOT_FILE" 2>/dev/null
       done
     `;
+  // Options are matched on their state column: a name containing "on"
+  // (monitor, onecmd) must not turn an OFF option on. Job control (monitor)
+  // is never restored: it gives every pipeline its own process group, which
+  // the runner's group kill then cannot reach.
   const optDump = isZsh
-    ? `setopt 2>/dev/null | sed 's/^/setopt /' | head -n 1000 >> "$SNAPSHOT_FILE"`
+    ? `setopt 2>/dev/null | grep -vxE '(no)?monitor' | sed 's/^/setopt /' | head -n 1000 >> "$SNAPSHOT_FILE"`
     : `
       shopt -p 2>/dev/null | head -n 1000 >> "$SNAPSHOT_FILE"
-      set -o 2>/dev/null | grep "on" | awk '{print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"
+      set -o 2>/dev/null | awk '$2 == "on" && $1 != "monitor" {print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"
       echo "shopt -s expand_aliases" >> "$SNAPSHOT_FILE"
     `;
   const aliasDump = `

package/src/runtime/agent/orchestrator/tools/spawn-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.10",
+  "version": "0.1.11",
   "_comment": "Synced from immutable spawn-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.10/mixdog-spawn-darwin-arm64",
-      "sha256": "8c20f4096c08a5159c62b28ada8aaed9d49d18ab21faaa1631e3eadadaadc91c"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-darwin-arm64",
+      "sha256": "6f1a7e6597dcc8785d12c5a13c42388110d9f4a2e5378ca2773172adbf50de60"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.10/mixdog-spawn-darwin-x64",
-      "sha256": "a35c66bf5c0121f1202ea69cc22a5804b0587a37929ebf3b66e08ec2b18b6b86"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-darwin-x64",
+      "sha256": "ff755eb9848cb3ce90f3df24136bb84a52f9ff6c67002c4d764beb6d7906e6b2"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.10/mixdog-spawn-linux-arm64",
-      "sha256": "463bc8bdb6abe49fd99fee53397365417cb6613ebabbfcd332e6b62fa3e79c37"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-linux-arm64",
+      "sha256": "3bc0fccde46537046d498a2b953aa92ef4afacc95c96c563ce1d6fb92d74e593"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.10/mixdog-spawn-linux-x64",
-      "sha256": "329a940ae3affc9fa5bcc9e6a48b2f7c8a783900f2de3a952de2422aa60413f5"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-linux-x64",
+      "sha256": "16dc4e3bf6636335c1325c88bbb5245529731525953466e761d363897b59aac7"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.10/mixdog-spawn-win32-arm64.exe",
-      "sha256": "a1719d2ea8f87707cb515a5e8e055ed56d6b48f3b717346b0a4ee63d40e562df"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-win32-arm64.exe",
+      "sha256": "c2fb5499d3d44405e27c79f8db65694299d61ddf029f466df68549fc2f2c5f5c"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.10/mixdog-spawn-win32-x64.exe",
-      "sha256": "ac65bd416d03f9c4e9e65eb04c6455a948551e726f74bd73bb32acbf4bc66d93"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-win32-x64.exe",
+      "sha256": "50531a9f033dc22eff3ec5b2a9d10441ffdfac0e50d9acf9047e4f302e5d70d9"
     }
   }
 }

package/src/runtime/attachments/office-extract.mjs

@@ -13,7 +13,10 @@ const ATTR_BOUND = 4096;
 const ATTRS = `[^<>]{0,${ATTR_BOUND}}`;
 const A = ATTRS;
 // A regex built from a raw template; the interpolations are pattern text.
-const re = (flags = '') => (strings, ...values) => new RegExp(String.raw(strings, ...values), flags);
+const re =
+  (flags = '') =>
+  (strings, ...values) =>
+    new RegExp(String.raw(strings, ...values), flags);
 // The patterns the per-cell / per-run loops use are built once.
 const V_RE = re()`<v(?:\s${A})?>([^<]*)</v>`;
 const T_RUN_RE = re('g')`<t(?:\s${A})?>([^<]*)</t>`;
@@ -384,16 +387,12 @@ function relationshipList(xml) {
 
 function sharedStringTable(xml) {
   if (!xml) return [];
-  return [...scanElements(xml, 'si')]
-    .filter((item) => item.inner !== null)
-    .map((item) => textRuns(item.inner));
+  return [...scanElements(xml, 'si')].filter((item) => item.inner !== null).map((item) => textRuns(item.inner));
 }
 
 // Concatenated <t> character data of one fragment.
 function textRuns(fragment) {
-  return [...fragment.matchAll(T_RUN_RE)]
-    .map(([, text]) => decodeXmlEntities(text))
-    .join('');
+  return [...fragment.matchAll(T_RUN_RE)].map(([, text]) => decodeXmlEntities(text)).join('');
 }
 
 // Excel stores a date as a day count and a percentage as a fraction, so a
@@ -421,7 +420,10 @@ function cellNumberFormats(xml) {
   if (!xml) return [];
   const custom = new Map(
     [...xml.matchAll(re('g')`<numFmt\b(${A}?)/?>`)]
-      .map(([, attributes]) => [/\bnumFmtId="(\d+)"/.exec(attributes)?.[1], /\bformatCode="([^"<>]*)"/.exec(attributes)?.[1]])
+      .map(([, attributes]) => [
+        /\bnumFmtId="(\d+)"/.exec(attributes)?.[1],
+        /\bformatCode="([^"<>]*)"/.exec(attributes)?.[1],
+      ])
       .filter(([id, code]) => id !== undefined && code !== undefined)
       .map(([id, code]) => [Number(id), decodeXmlEntities(code)])
   );
@@ -629,7 +631,7 @@ function relatedPart(target, ownerPart) {
   const base = String(ownerPart).replace(/\/[^/]+$/, '');
   const value = String(target).replace(/^\//, '');
   if (!value.startsWith('..')) return value.startsWith('xl/') ? value : `${base}/${value}`;
-  return value.replace(/^\.\.\//, `${base.replace(/\/[^/]+$/, '')}/`);
+  return value.replace(/^\.\.\//, () => `${base.replace(/\/[^/]+$/, '')}/`);
 }
 
 // A sheet's chart is its message, and it lives outside the cell grid: read as

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({