From 0900eed92843186d53117d829e06ad319448b322 Mon Sep 17 00:00:00 2001
From: Julien Hurault <julien.hurault@gmail.com>
Date: Fri, 31 Jul 2026 13:18:49 +0200
Subject: [PATCH 1/2] #896 fix(automation): run hosted schedules internally
 (#906)

* #896 fix(automation): run hosted schedules internally

* #896 test(automation): prove minute wakeup and session run

* #896 fix(automation): adapt scheduler to AgentHost lifecycle

* #863 fix(full-app): wire default front plugins

* #863 fix(full-app): build automation front package

* #896 fix(automation): migrate dev DB before runs

* #896 fix(full-app): address hosted agent sessions

* #896 feat(automation): prefix run session titles

* #896 feat(automation): add pause and last-run status

* #896 fix(automation): refresh scheduled runs live

* #896 feat(automation): stream run updates

* #896 fix(automation): recover abandoned hosted runs

* #896 fix(ci): decouple migrations from runtime secrets

* #863 refactor(full-app): register automation directly

* #863 test(full-app): remove brittle source parity check

* #896 docs: plan managed host worker lifecycle

* #896 refactor(automation): manage scheduler as a host worker

* fix(cli): use Fastify 5 static header API

* #896 refactor(automation): rely on durable shutdown recovery

* refactor(core): keep database resolution migration-local

* refactor(core): reuse file secret resolution for migrations
---
 apps/full-app/README.md                       |  18 +-
 apps/full-app/package.json                    |   4 +-
 apps/full-app/src/front/main.tsx              |   4 +
 docs/issues/590/plan.md                       |  13 +-
 .../workspaceAgentDispatcher.test.ts          |   8 +-
 .../src/server/workspaceAgentDispatcher.ts    |   2 +-
 .../src/shared/workspaceAgentDispatcher.ts    |   2 +
 .../workspacesModeRuntimePlugins.test.ts      |   4 +-
 packages/cli/src/server/modeApps.ts           |   8 +-
 .../src/server/__tests__/migrations.test.ts   |  39 ++++
 packages/core/src/server/db/migrate.ts        |   2 +-
 packages/core/src/server/migrations.ts        |  16 +-
 plugins/boring-automation/README.md           |  12 +-
 .../src/front/AutomationCard.tsx              |  39 +++-
 .../src/front/AutomationPanel.tsx             | 122 ++++++++---
 .../front/__tests__/AutomationPanel.test.tsx  |  73 ++++++-
 .../src/front/__tests__/client.test.ts        |  33 +++
 plugins/boring-automation/src/front/client.ts |  58 ++++-
 .../src/server/__tests__/fileStore.test.ts    |  26 +++
 .../__tests__/hostedDueCoordinator.test.ts    |  48 +++++
 .../__tests__/hostedDueRunService.test.ts     | 204 ++++++++++++++++++
 .../server/__tests__/hostedScheduler.test.ts  | 125 +++++++++++
 .../__tests__/manualRunExecutor.test.ts       | 115 +++++++++-
 .../src/server/__tests__/migrations.test.ts   |  78 +++++++
 .../__tests__/nestedToolDispatch.test.ts      |   6 +
 .../src/server/__tests__/operations.test.ts   |   2 +
 .../server/__tests__/postgresStore.test.ts    |  33 ++-
 .../src/server/__tests__/routes.test.ts       |  85 ++++++++
 .../src/server/__tests__/runEventBus.test.ts  |  65 ++++++
 .../src/server/__tests__/serverPlugin.test.ts | 120 +++++++++++
 .../src/server/automationTool.ts              |   1 +
 .../boring-automation/src/server/fileStore.ts |  34 ++-
 .../src/server/hostedDueCoordinator.ts        |  28 +++
 .../src/server/hostedDueRunService.ts         |  51 ++++-
 .../src/server/hostedScheduler.ts             | 102 +++++++++
 plugins/boring-automation/src/server/index.ts |  72 +++++--
 .../src/server/manualRunExecutor.ts           | 106 +++++++--
 .../src/server/postgresStore.ts               |  95 +++++++-
 .../boring-automation/src/server/routes.ts    |  65 +++++-
 .../src/server/runEventBus.ts                 | 110 ++++++++++
 plugins/boring-automation/src/server/store.ts |   8 +-
 .../src/shared/__tests__/schedule.test.ts     |  10 +-
 .../src/shared/error-codes.ts                 |   1 +
 .../boring-automation/src/shared/schedule.ts  |  10 +-
 plugins/boring-automation/src/shared/types.ts |  11 +
 .../workspace-components/src/fixtures.tsx     |   3 +
 46 files changed, 1930 insertions(+), 141 deletions(-)
 create mode 100644 packages/core/src/server/__tests__/migrations.test.ts
 create mode 100644 plugins/boring-automation/src/server/__tests__/hostedDueCoordinator.test.ts
 create mode 100644 plugins/boring-automation/src/server/__tests__/hostedDueRunService.test.ts
 create mode 100644 plugins/boring-automation/src/server/__tests__/hostedScheduler.test.ts
 create mode 100644 plugins/boring-automation/src/server/__tests__/runEventBus.test.ts
 create mode 100644 plugins/boring-automation/src/server/hostedDueCoordinator.ts
 create mode 100644 plugins/boring-automation/src/server/hostedScheduler.ts
 create mode 100644 plugins/boring-automation/src/server/runEventBus.ts

diff --git a/apps/full-app/README.md b/apps/full-app/README.md
index 669d7b95e..734bb00dd 100644
--- a/apps/full-app/README.md
+++ b/apps/full-app/README.md
@@ -52,10 +52,17 @@ pnpm --filter full-app dev
 
 Open `http://localhost:5173`.
 
-### Hosted automation trigger
+### Hosted automation scheduler
 
-Set `BORING_AUTOMATION_TRIGGER_TOKEN` to a deployment secret. The platform
-scheduler invokes:
+The hosted Automation plugin starts an internal Croner wake-up once per minute
+by default and evaluates the current minute once when Fastify becomes ready.
+Each automation creator is re-authorized before execution, overlapping ticks in
+one process are skipped, and database constraints prevent duplicate active or
+scheduled-minute runs across processes.
+
+For a deployment that intentionally uses an external scheduler, set
+`BORING_AUTOMATION_INTERNAL_SCHEDULER=false` and set
+`BORING_AUTOMATION_TRIGGER_TOKEN` to a deployment secret. Invoke:
 
 ```bash
 curl --fail --silent --show-error -X POST \
@@ -63,8 +70,8 @@ curl --fail --silent --show-error -X POST \
   http://localhost:5173/api/v1/boring-automation/due/hosted
 ```
 
-The token is service-principal authentication only; each automation creator is
-re-authorized before execution. The plugin does not start a timer.
+The token authenticates only the external service principal. The endpoint stays
+available as an operational fallback when the internal scheduler is enabled.
 
 ## Scripts
 
@@ -119,6 +126,7 @@ Common optional:
 | `PORT` / `HOST` / `LOG_LEVEL` | `3000` / `0.0.0.0` / `info` | HTTP server |
 | `CORS_ORIGINS` | `http://localhost:3000,http://localhost:5173` | Allowed origins |
 | `BORING_PLUGIN_AUTHORING` | `0` | `1` installs the plugin-authoring surface |
+| `BORING_AUTOMATION_INTERNAL_SCHEDULER` | `true` | Set to `false` only when an external scheduler owns hosted Automation wake-ups |
 | `ENABLE_DEV_LOGIN` | `0` | Dev server only. Set `1` to enable `GET /dev-login`, which creates/signs in a local dev user and redirects to `/`. Ignored in `NODE_ENV=production`. |
 | `DEV_LOGIN_EMAIL`, `DEV_LOGIN_PASSWORD`, `DEV_LOGIN_NAME` | `dev@example.test`, strong local password, `Dev` | Optional credentials for `ENABLE_DEV_LOGIN=1`. |
 | `RESEND_API_KEY` | — | Resend mail transport |
diff --git a/apps/full-app/package.json b/apps/full-app/package.json
index 23b3209ed..ccc6699f2 100644
--- a/apps/full-app/package.json
+++ b/apps/full-app/package.json
@@ -4,8 +4,8 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "pnpm --filter @hachej/boring-ui-kit build && pnpm --filter @hachej/boring-sandbox build && pnpm --filter @hachej/boring-bash build && pnpm --filter @hachej/boring-agent build && pnpm --filter @hachej/boring-workspace build && pnpm --filter @hachej/boring-core build && pnpm --filter @hachej/boring-mcp build && pnpm --filter @hachej/boring-governance build && NODE_ENV=development tsx src/server/dev.ts",
-    "build": "pnpm --filter @hachej/boring-ui-kit build && pnpm --filter @hachej/boring-sandbox build && pnpm --filter @hachej/boring-bash build && pnpm --filter @hachej/boring-agent build && pnpm --filter @hachej/boring-workspace build && pnpm --filter @hachej/boring-core build && pnpm --filter @hachej/boring-mcp build && pnpm --filter @hachej/boring-governance build && tsx ../../packages/workspace/scripts/build-app.mts",
+    "dev": "pnpm --filter @hachej/boring-ui-kit build && pnpm --filter @hachej/boring-sandbox build && pnpm --filter @hachej/boring-bash build && pnpm --filter @hachej/boring-agent build && pnpm --filter @hachej/boring-workspace build && pnpm --filter @hachej/boring-core build && pnpm --filter @hachej/boring-automation build && pnpm --filter @hachej/boring-mcp build && pnpm --filter @hachej/boring-governance build && NODE_ENV=development tsx src/server/migrate.ts && NODE_ENV=development tsx src/server/dev.ts",
+    "build": "pnpm --filter @hachej/boring-ui-kit build && pnpm --filter @hachej/boring-sandbox build && pnpm --filter @hachej/boring-bash build && pnpm --filter @hachej/boring-agent build && pnpm --filter @hachej/boring-workspace build && pnpm --filter @hachej/boring-core build && pnpm --filter @hachej/boring-automation build && pnpm --filter @hachej/boring-mcp build && pnpm --filter @hachej/boring-governance build && tsx ../../packages/workspace/scripts/build-app.mts",
     "start": "NODE_ENV=production node dist/server/main.js",
     "start:worker": "NODE_ENV=production node dist/server/agent-worker.js",
     "migrate": "tsx src/server/migrate.ts",
diff --git a/apps/full-app/src/front/main.tsx b/apps/full-app/src/front/main.tsx
index 0c2249219..1615d96b6 100644
--- a/apps/full-app/src/front/main.tsx
+++ b/apps/full-app/src/front/main.tsx
@@ -17,10 +17,12 @@ import {
 import '@hachej/boring-core/app/front/styles.css'
 import { GovernanceUsagePanel, createGovernanceCompanyAdmin } from '@hachej/boring-governance/front'
 import { BoringMcpSourcesOverlay } from '@hachej/boring-mcp/front'
+import boringAutomationPlugin from '@hachej/boring-automation/front'
 import { PublicHeroDescription } from './PublicHeroDescription'
 import { fullAppBoringMcpOptions } from './boringMcp'
 
 const PRODUCT_NAME = 'Seneca AI'
+const fullAppFrontPlugins = [boringAutomationPlugin]
 
 // Show the Buy-credits button when the server has Lemon Squeezy checkout wired
 // (set this alongside the server-side LS env). The checkout itself is created
@@ -121,6 +123,8 @@ const chatParams = {
 createRoot(document.getElementById('root')!).render(
   <>
     <CoreWorkspaceAgentFront
+      agentTypeId="default"
+      plugins={fullAppFrontPlugins}
       apiBaseUrl=""
       apiTimeout={10_000}
       persistenceEnabled
diff --git a/docs/issues/590/plan.md b/docs/issues/590/plan.md
index 1606756c6..ca94c3f6f 100644
--- a/docs/issues/590/plan.md
+++ b/docs/issues/590/plan.md
@@ -291,13 +291,14 @@ Execution slice:
 - creator authorization re-check and creator-scoped execution;
 - operational proof across multiple invocations.
 
-**Status:** implemented. The platform invokes `POST /api/v1/boring-automation/due/hosted` with `Authorization: Bearer $BORING_AUTOMATION_TRIGGER_TOKEN`. There is no plugin-owned timer.
+**Status:** implemented, then superseded by #896 for single-node hosted operation. The plugin now owns a lifecycle-bound internal Croner wake-up by default. The authenticated `POST /api/v1/boring-automation/due/hosted` endpoint remains available for operational fallback or multi-replica deployments that explicitly disable the internal scheduler.
 
 **Review budget:** high.
 
 ## Schedule Policy To Preserve During Replan
 
-- no hidden in-process timer without lifecycle/dispose support;
+- the default hosted wake-up is explicit, process-local, non-overlapping, unreferenced, and drained before agent runtime shutdown;
+- multi-replica deployments may explicitly disable it and use the authenticated endpoint externally;
 - no unbounded backfill after downtime;
 - skip/conflict while the same automation is already running;
 - timezone-aware due calculation with explicit DST behavior;
@@ -377,7 +378,7 @@ Not a wide refactor. Any missing generic workspace/agent capability must be plan
 - Hosted Markdown as a predetermined canonical format.
 - Prompt version-history UI beyond run snapshots.
 - New transcript viewer.
-- Hidden plugin timers.
+- Timers without explicit lifecycle, overlap, logging, and opt-out contracts.
 - Automation-specific core logic.
 - Runtime/untrusted plugin support.
 - Boring Claw/GitHub auto-picker controls from #197.
@@ -387,7 +388,7 @@ Not a wide refactor. Any missing generic workspace/agent capability must be plan
 Confirmed by Slice 0:
 
 - headless execution uses the host's existing `Agent.send()` through a minimal trusted dispatcher seam;
-- due evaluation is externally invoked, never a hidden plugin timer;
+- due evaluation uses the same service for the #896 internal hosted wake-up and authenticated external fallback;
 - hosted orchestration stays on the public host while sandbox/worker executes workspace operations;
 - first-pass token totals come from live usage events, not direct billing-ledger queries.
 
@@ -401,5 +402,5 @@ Owner decisions recorded before Slice 5:
 
 - Slice 0 state: complete; see `docs/issues/590/seam-spike.md`.
 - `ready-for-agent`: Slice 2 UI, Slice 3A generic dispatcher, then Slice 3B local manual executor.
-- `ready-for-human`: final end-to-end hosted smoke and production scheduler wiring.
-- The implementation is complete; deployment must configure `BORING_AUTOMATION_TRIGGER_TOKEN` and invoke the hosted endpoint from its scheduler.
+- `ready-for-human`: final end-to-end hosted smoke.
+- #896 removed the default deployment scheduler requirement: single-node hosted apps start the internal wake-up automatically. External scheduler deployments must explicitly opt out and configure `BORING_AUTOMATION_TRIGGER_TOKEN`.
diff --git a/packages/agent/src/server/__tests__/workspaceAgentDispatcher.test.ts b/packages/agent/src/server/__tests__/workspaceAgentDispatcher.test.ts
index c17a905f1..b12f09953 100644
--- a/packages/agent/src/server/__tests__/workspaceAgentDispatcher.test.ts
+++ b/packages/agent/src/server/__tests__/workspaceAgentDispatcher.test.ts
@@ -54,6 +54,7 @@ describe('workspace agent dispatcher', () => {
 
     const dispatched = await dispatcher.dispatch!({
       requestId: 'run-1',
+      title: 'Automation Daily summary: run this',
       content: 'run this',
       model: { provider: 'test', id: 'gpt-5.5' },
     })
@@ -61,7 +62,12 @@ describe('workspace agent dispatcher', () => {
       ref: { agentTypeId: 'default', sessionId: 'session-1' },
       receipt: { accepted: true, disposition: 'prompt', clientNonce: 'run-1' },
     })
-    expect(gateway.createSession).toHaveBeenCalledWith(expect.objectContaining({ scope, agentTypeId: 'default', requestId: 'run-1' }))
+    expect(gateway.createSession).toHaveBeenCalledWith(expect.objectContaining({
+      scope,
+      agentTypeId: 'default',
+      requestId: 'run-1',
+      title: 'Automation Daily summary: run this',
+    }))
     expect(gateway.sends).toEqual([expect.objectContaining({ kind: 'prompt', requestId: 'run-1', clientNonce: 'run-1' })])
 
     const received = []
diff --git a/packages/agent/src/server/workspaceAgentDispatcher.ts b/packages/agent/src/server/workspaceAgentDispatcher.ts
index e0a9b1678..a2c2e8434 100644
--- a/packages/agent/src/server/workspaceAgentDispatcher.ts
+++ b/packages/agent/src/server/workspaceAgentDispatcher.ts
@@ -100,7 +100,7 @@ async function dispatchGatewayInput(
         scope: binding.scope,
         agentTypeId: binding.agentTypeId,
         requestId,
-        title: contentToText(input.content ?? input.message).slice(0, 80) || undefined,
+        title: input.title?.trim() || contentToText(input.content ?? input.message).slice(0, 80) || undefined,
       })
   const connection = await binding.gateway.connectSession({
     scope: binding.scope,
diff --git a/packages/agent/src/shared/workspaceAgentDispatcher.ts b/packages/agent/src/shared/workspaceAgentDispatcher.ts
index b5bf051a7..72a2e0f93 100644
--- a/packages/agent/src/shared/workspaceAgentDispatcher.ts
+++ b/packages/agent/src/shared/workspaceAgentDispatcher.ts
@@ -15,6 +15,8 @@ export interface WorkspaceAgentDispatcherContext {
 export type WorkspaceAgentDispatcherSendInput = Omit<AgentSendInput, 'ctx'>
 
 export interface WorkspaceAgentDispatcherDispatchInput extends WorkspaceAgentDispatcherSendInput {
+  /** Optional title for a newly created addressed session. */
+  title?: string
   /** Durable caller-owned idempotency key. */
   requestId: string
   /** Defaults to requestId. */
diff --git a/packages/cli/src/__tests__/workspacesModeRuntimePlugins.test.ts b/packages/cli/src/__tests__/workspacesModeRuntimePlugins.test.ts
index 06fe56120..503e873c6 100644
--- a/packages/cli/src/__tests__/workspacesModeRuntimePlugins.test.ts
+++ b/packages/cli/src/__tests__/workspacesModeRuntimePlugins.test.ts
@@ -206,8 +206,10 @@ describe("workspaces mode runtime plugin wiring", () => {
     const app = await createWorkspacesModeApp({ mode: "direct", registryPath, provisionWorkspace: false })
     const address = await app.listen({ port: 0, host: "127.0.0.1" })
     const sse = await openSse(`${address}/api/v1/agent-plugins/events?workspaceId=${encodeURIComponent(registeredA.id)}`)
+    const automationSse = await openSse(`${address}/api/v1/boring-automation/events?workspaceId=${encodeURIComponent(registeredA.id)}`)
 
     try {
+      await expect(automationSse.nextEvent((message) => message.event === "ready")).resolves.toMatchObject({ event: "ready" })
       // The CLI bundles @hachej/boring-ask-user as an internal default plugin
       // package. Internal plugins are statically bundled into the app front and
       // never appear on the SSE channel — only the external test fixtures do.
@@ -308,7 +310,7 @@ describe("workspaces mode runtime plugin wiring", () => {
       })
       expect(automationB.json()).toMatchObject({ ok: true, automations: [] })
     } finally {
-      await sse.close()
+      await Promise.all([sse.close(), automationSse.close()])
       await app.close()
     }
   }, 60_000)
diff --git a/packages/cli/src/server/modeApps.ts b/packages/cli/src/server/modeApps.ts
index f696aa035..bca382b52 100644
--- a/packages/cli/src/server/modeApps.ts
+++ b/packages/cli/src/server/modeApps.ts
@@ -512,7 +512,7 @@ export async function createWorkspacesModeApp(opts: {
   registryPath?: string
   provisionWorkspace?: boolean
 }): Promise<FastifyInstance> {
-  const [workspaceAppServer, workspaceServer, agentServer, agentShared, fastifyModule, { createPluginFrontRuntimeHost }, { automationRoutes, createBoringAutomationTool, DueRunService, FileAutomationStore, ManualRunExecutor, resolveAutomationOperationsForActor }, pluginDiscovery] = await Promise.all([
+  const [workspaceAppServer, workspaceServer, agentServer, agentShared, fastifyModule, { createPluginFrontRuntimeHost }, { automationRoutes, createBoringAutomationTool, DueRunService, FileAutomationStore, InMemoryAutomationRunEventBus, ManualRunExecutor, resolveAutomationOperationsForActor }, pluginDiscovery] = await Promise.all([
     import("@hachej/boring-workspace/app/server"),
     import("@hachej/boring-workspace/server"),
     import("@hachej/boring-agent/server"),
@@ -584,6 +584,8 @@ export async function createWorkspacesModeApp(opts: {
   const pluginPiSnapshots = new Map<string, CliPluginPiSnapshot>()
   const runtimeProvisioningByWorkspace = new Map<string, WorkspaceProvisioningResult | undefined>()
   const automationStores = new Map<string, InstanceType<typeof FileAutomationStore>>()
+  const automationEventBus = new InMemoryAutomationRunEventBus()
+  app.addHook("onClose", async () => await automationEventBus.close())
   let workspaceAgentDispatcher: WorkspaceAgentDispatcherResolver | undefined
 
   function getBridge(workspaceId: string) {
@@ -652,6 +654,7 @@ export async function createWorkspacesModeApp(opts: {
       store: automationStore(workspace),
       dispatcherResolver: workspaceAgentDispatcher,
       actorResolver: () => ({ workspaceId: workspace.id, userId: "local" }),
+      eventPublisher: automationEventBus,
     })
   }
 
@@ -666,6 +669,7 @@ export async function createWorkspacesModeApp(opts: {
             store,
             dispatcherResolver: workspaceAgentDispatcher,
             actorResolver: () => actor,
+            eventPublisher: automationEventBus,
           })
         },
         localUserId: "local",
@@ -933,6 +937,8 @@ export async function createWorkspacesModeApp(opts: {
         executor: await automationExecutorForRequest(request),
       })
     },
+    actorResolver: async (request) => ({ workspaceId: (await workspaceFromRequest(request)).id, userId: "local" }),
+    eventBus: automationEventBus,
   })
 
   await app.register(workspaceServer.uiRoutes, {
diff --git a/packages/core/src/server/__tests__/migrations.test.ts b/packages/core/src/server/__tests__/migrations.test.ts
new file mode 100644
index 000000000..a62694058
--- /dev/null
+++ b/packages/core/src/server/__tests__/migrations.test.ts
@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { runMigrations } = vi.hoisted(() => ({
+  runMigrations: vi.fn(async () => undefined),
+}))
+
+vi.mock('../db/index.js', () => ({ runMigrations }))
+
+import { runCoreMigrationsFromEnv } from '../migrations.js'
+
+describe('runCoreMigrationsFromEnv', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('loads only the database URL required for schema deployment', async () => {
+    const env = {
+      DATABASE_URL: 'postgres://test',
+      NODE_ENV: 'production',
+      BETTER_AUTH_SECRET_FILE: '/missing/unrelated-secret',
+    }
+
+    await runCoreMigrationsFromEnv({ loadConfigOptions: { env } })
+
+    expect(runMigrations).toHaveBeenCalledWith({ databaseUrl: 'postgres://test' }, expect.any(Object))
+  })
+
+  it('rejects conflicting inline and file database secrets', async () => {
+    await expect(runCoreMigrationsFromEnv({
+      loadConfigOptions: {
+        env: {
+          DATABASE_URL: 'postgres://test',
+          DATABASE_URL_FILE: '/tmp/database-url',
+        },
+      },
+    })).rejects.toMatchObject({
+      issues: [expect.objectContaining({ path: ['env', 'DATABASE_URL_FILE'] })],
+    })
+    expect(runMigrations).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/core/src/server/db/migrate.ts b/packages/core/src/server/db/migrate.ts
index 4e1a3e2da..5af893144 100644
--- a/packages/core/src/server/db/migrate.ts
+++ b/packages/core/src/server/db/migrate.ts
@@ -37,7 +37,7 @@ export interface RunMigrationsOptions {
 }
 
 export async function runMigrations(
-  config: CoreConfig,
+  config: Pick<CoreConfig, 'databaseUrl'>,
   options?: RunMigrationsOptions,
 ): Promise<void> {
   if (!config.databaseUrl) {
diff --git a/packages/core/src/server/migrations.ts b/packages/core/src/server/migrations.ts
index f13d24a10..881e0d4c9 100644
--- a/packages/core/src/server/migrations.ts
+++ b/packages/core/src/server/migrations.ts
@@ -1,4 +1,5 @@
-import { loadConfig, type LoadConfigOptions } from './config/index.js'
+import type { LoadConfigOptions } from './config/index.js'
+import { resolveConfigFileSecrets } from './config/fileSecrets.js'
 import { runMigrations, type RunMigrationsOptions } from './db/index.js'
 
 export interface RunCoreMigrationsFromEnvOptions extends RunMigrationsOptions {
@@ -9,7 +10,16 @@ export interface RunCoreMigrationsFromEnvOptions extends RunMigrationsOptions {
 export async function runCoreMigrationsFromEnv(
   options: RunCoreMigrationsFromEnvOptions = {},
 ): Promise<void> {
-  const config = await loadConfig(options.loadConfigOptions)
-  await runMigrations(config, options)
+  // Schema deployment only needs DATABASE_URL; unrelated runtime secrets must not block migrations.
+  await runMigrations({ databaseUrl: resolveMigrationDatabaseUrl(options.loadConfigOptions) }, options)
   options.log?.log('migrations complete')
 }
+
+function resolveMigrationDatabaseUrl(options?: Pick<LoadConfigOptions, 'env'>): string | null {
+  const env = options?.env ?? (process.env as Record<string, string | undefined>)
+  const fileSecrets = resolveConfigFileSecrets({
+    DATABASE_URL: env.DATABASE_URL,
+    DATABASE_URL_FILE: env.DATABASE_URL_FILE,
+  })
+  return fileSecrets.DATABASE_URL ?? env.DATABASE_URL ?? null
+}
diff --git a/plugins/boring-automation/README.md b/plugins/boring-automation/README.md
index 4efea302f..9265cae95 100644
--- a/plugins/boring-automation/README.md
+++ b/plugins/boring-automation/README.md
@@ -38,10 +38,10 @@ The agent tool requires explicit `provider:model-id` syntax for model-bearing `c
 
 Existing UI and HTTP routes retain compatibility with legacy unqualified saved model values. Those values remain editable but fail safely when run until corrected. The tool does not silently guess a provider.
 
-## Local and hosted execution
-
 Every mode stores the canonical prompt as a normal workspace Markdown file at `.agents/automation/<automation-id>.md`. PostgreSQL stores hosted automation metadata only; the prompt path is derived deterministically from the automation id, and runtime reads use the workspace file.
 
+## Local and hosted execution
+
 Local CLI support includes:
 
 - workspace-scoped file-backed metadata and canonical Markdown prompts;
@@ -51,15 +51,17 @@ Local CLI support includes:
 - partial live usage totals when providers emit usage events;
 - deterministic current-minute cron evaluation invoked through the loopback due endpoint.
 
-Scheduling has no background timer. User-owned cron/systemd may invoke `POST /api/v1/boring-automation/due` once per minute while the CLI server is running. Missed minutes are not backfilled.
+Local scheduling has no background timer. User-owned cron/systemd may invoke `POST /api/v1/boring-automation/due` once per minute while the CLI server is running. Missed minutes are not backfilled.
+
+Hosted persistence and creator-scoped execution are available in full-app. The deployment migration callback is `runBoringAutomationMigrations`. When hosted due execution is composed, the plugin starts an internal Croner wake-up once per minute and evaluates the current minute once at startup. Every tick re-checks each creator, prevents process-local overlap, and relies on database active-run and scheduled-minute constraints as the cross-process execution guard. Active executors heartbeat durable run rows every 30 seconds; each hosted tick terminalizes active rows whose heartbeat is more than five minutes stale before evaluating new work. This releases automations abandoned by an ungraceful worker exit without terminating healthy runs owned by another replica. Fastify shutdown stops future timer ticks without waiting for an active execution; durable heartbeat reconciliation owns interrupted runs across deploys or crashes. The timer is unreferenced so it cannot keep Node alive by itself.
 
-Hosted metadata persistence and creator-scoped execution are available in full-app. The deployment migration removes the unused prototype prompt columns if they exist. Configure `BORING_AUTOMATION_TRIGGER_TOKEN` and have the platform scheduler invoke `POST /api/v1/boring-automation/due/hosted` with `Authorization: Bearer <token>`. The endpoint re-checks each creator and fails closed when authorization is lost.
+Set `BORING_AUTOMATION_INTERNAL_SCHEDULER=false` (or compose `hostedSchedulerEnabled: false`) when a multi-replica deployment intentionally owns wake-ups externally. For that mode, configure `BORING_AUTOMATION_TRIGGER_TOKEN` and invoke `POST /api/v1/boring-automation/due/hosted` with `Authorization: Bearer <token>`. The authenticated endpoint remains available as an operational fallback when the internal scheduler is enabled.
 
 ## Enable gate and rollback
 
 The trusted server plugin enables the agent tool by default. Host composition can set `agentToolEnabled: false` at boot to remove only `boring_automation`; UI, HTTP routes, stored automations, prompts, runs, and sessions remain available. Server tool changes and gate changes require a host restart; `/reload` only affects runtime plugin resources.
 
-Prompt rollback uses the normal workspace file history/backups; PostgreSQL does not mirror prompt bodies.
+Rollback is capability-only: disable/remove the tool contribution and restart. No data migration or deletion is required. Prompt rollback uses the normal workspace file history/backups; PostgreSQL does not mirror prompt bodies.
 
 ## Deterministic UI review
 
diff --git a/plugins/boring-automation/src/front/AutomationCard.tsx b/plugins/boring-automation/src/front/AutomationCard.tsx
index 428decf48..100c859d0 100644
--- a/plugins/boring-automation/src/front/AutomationCard.tsx
+++ b/plugins/boring-automation/src/front/AutomationCard.tsx
@@ -1,9 +1,9 @@
 "use client"
 
-import { ChevronDown, FileText, Play, Trash2 } from "lucide-react"
+import { ChevronDown, FileText, Pause, Play, Trash2 } from "lucide-react"
 import { Button, cn } from "@hachej/boring-ui-kit"
 import type { Automation, AutomationRun } from "../shared"
-import { formatDateTime } from "./format"
+import { formatDateTime, statusLabel, statusTone } from "./format"
 import { RunHistory } from "./RunHistory"
 
 export function AutomationCard({
@@ -13,10 +13,13 @@ export function AutomationCard({
   deleting,
   runs,
   runsLoading,
+  runsUnavailable,
   runningNow,
+  togglingEnabled,
   onToggle,
   onEdit,
   onRunNow,
+  onToggleEnabled,
   onOpenPrompt,
   onDeleteRequest,
   onDeleteCancel,
@@ -29,10 +32,13 @@ export function AutomationCard({
   deleting: boolean
   runs: AutomationRun[]
   runsLoading: boolean
+  runsUnavailable: boolean
   runningNow: boolean
+  togglingEnabled: boolean
   onToggle: () => void
   onEdit: () => void
   onRunNow: () => void
+  onToggleEnabled: () => void
   onOpenPrompt: () => void
   onDeleteRequest: () => void
   onDeleteCancel: () => void
@@ -41,6 +47,7 @@ export function AutomationCard({
 }) {
   const historyId = `automation-runs-${automation.id}`
   const deleteTitleId = `automation-delete-title-${automation.id}`
+  const lastRun = runs[0]
   return (
     <article className="border-b border-border/60 bg-card/80 last:border-b-0">
       <div className="group flex min-h-14 w-full flex-wrap items-center gap-x-2 gap-y-1.5 px-3 text-[13px] transition-colors hover:bg-muted/50 focus-within:bg-muted/50 motion-reduce:transition-none sm:flex-nowrap" style={{ minHeight: compactControls ? 48 : 56, paddingBlock: compactControls ? 4 : 6 }}>
@@ -56,21 +63,37 @@ export function AutomationCard({
           <span className={cn("size-2 shrink-0 rounded-full", automation.enabled ? "bg-[color:var(--success)]" : "bg-muted-foreground/40")} aria-hidden="true" />
           <span className="min-w-0 flex-1">
             <span className="block truncate font-medium text-foreground">{automation.title}</span>
-            <span className="block truncate text-xs text-muted-foreground">{automation.enabled ? "Active" : "Paused"} · {automation.cron} · {automation.timezone} · {automation.model}</span>
+            <span className="block truncate text-xs text-muted-foreground">
+              {automation.enabled ? "Active" : "Paused"} · {automation.cron} · {automation.timezone} · {automation.model}
+              <span className="ml-1.5">· Last run </span>
+              {runsLoading ? (
+                <span>Loading…</span>
+              ) : runsUnavailable ? (
+                <span>Unavailable</span>
+              ) : lastRun ? (
+                <span aria-label={`Last run ${statusLabel(lastRun.status)}`} className={cn("rounded-full px-1.5 py-0.5 text-[10px] font-medium", statusTone(lastRun.status))}>{statusLabel(lastRun.status)}</span>
+              ) : (
+                <span>None</span>
+              )}
+            </span>
           </span>
           <span className="hidden shrink-0 text-xs text-muted-foreground sm:block">Updated {formatDateTime(automation.updatedAt)}</span>
         </button>
         <div className="flex min-w-0 items-center gap-1" style={{ marginLeft: "auto" }}>
-          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onRunNow} disabled={runningNow} aria-label={`Run ${automation.title} now`}>
+          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onToggleEnabled} disabled={togglingEnabled || deleting} aria-label={`${automation.enabled ? "Pause" : "Resume"} ${automation.title}`}>
+            {automation.enabled ? <Pause className="size-3.5" aria-hidden="true" /> : <Play className="size-3.5" aria-hidden="true" />}
+            {togglingEnabled ? "Saving…" : automation.enabled ? "Pause" : "Resume"}
+          </Button>
+          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onRunNow} disabled={runningNow || togglingEnabled || deleting} aria-label={`Run ${automation.title} now`}>
             <Play className="size-3.5" aria-hidden="true" />
             {runningNow ? "Running…" : "Run now"}
           </Button>
-          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onOpenPrompt} aria-label={`Open prompt for ${automation.title}`}>
+          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onOpenPrompt} disabled={togglingEnabled || deleting} aria-label={`Open prompt for ${automation.title}`}>
             <FileText className="size-3.5" aria-hidden="true" />
             Prompt
           </Button>
-          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onEdit}>Edit</Button>
-          <Button style={{ height: compactControls ? 32 : 44, minHeight: compactControls ? 32 : 44, minWidth: compactControls ? 32 : 44, width: compactControls ? 32 : 44 }} type="button" variant="ghost" size="icon-sm" aria-label={`Delete ${automation.title}`} title="Delete" onClick={onDeleteRequest}>
+          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onEdit} disabled={togglingEnabled || deleting}>Edit</Button>
+          <Button style={{ height: compactControls ? 32 : 44, minHeight: compactControls ? 32 : 44, minWidth: compactControls ? 32 : 44, width: compactControls ? 32 : 44 }} type="button" variant="ghost" size="icon-sm" aria-label={`Delete ${automation.title}`} title="Delete" onClick={onDeleteRequest} disabled={togglingEnabled || deleting}>
             <Trash2 className="size-4" aria-hidden="true" />
           </Button>
         </div>
@@ -81,7 +104,7 @@ export function AutomationCard({
           <div id={deleteTitleId} className="font-medium text-foreground">Delete this automation?</div>
           <p className="mt-1 text-muted-foreground">Metadata only; prompts, runs, and sessions stay.</p>
           <div className="mt-3 flex gap-2">
-            <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="destructive" size="sm" onClick={onDeleteConfirm}>Delete</Button>
+            <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="destructive" size="sm" onClick={onDeleteConfirm} disabled={togglingEnabled}>Delete</Button>
             <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={onDeleteCancel}>Cancel</Button>
           </div>
         </div>
diff --git a/plugins/boring-automation/src/front/AutomationPanel.tsx b/plugins/boring-automation/src/front/AutomationPanel.tsx
index 94a217fd5..f459e368d 100644
--- a/plugins/boring-automation/src/front/AutomationPanel.tsx
+++ b/plugins/boring-automation/src/front/AutomationPanel.tsx
@@ -15,6 +15,7 @@ interface AutomationDetailState {
   promptLoading: boolean
   runs: AutomationRun[]
   runsLoading: boolean
+  runsUnavailable: boolean
 }
 
 interface SaveNoticeState {
@@ -27,6 +28,9 @@ type EditorState =
   | { mode: "create" }
   | { mode: "edit"; automationId: string }
 
+const RUN_RECONCILE_INTERVAL_MS = 30_000
+const RUN_STREAM_RECONNECT_MS = 2_000
+
 function errorMessage(error: unknown): string {
   if (error instanceof AutomationClientError) return error.message
   if (error instanceof Error) return error.message
@@ -39,6 +43,7 @@ function detailWithPatch(previous: AutomationDetailState | undefined, patch: Par
     promptLoading: previous?.promptLoading ?? false,
     runs: previous?.runs ?? [],
     runsLoading: previous?.runsLoading ?? false,
+    runsUnavailable: previous?.runsUnavailable ?? false,
     ...patch,
   }
 }
@@ -69,12 +74,19 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
   const [loading, setLoading] = useState(true)
   const [saving, setSaving] = useState(false)
   const [runningNowIds, setRunningNowIds] = useState<Set<string>>(() => new Set())
+  const [togglingEnabledIds, setTogglingEnabledIds] = useState<Set<string>>(() => new Set())
   const [routeError, setRouteError] = useState<string | null>(null)
   const [shellError, setShellError] = useState<string | null>(null)
   const [saveNotice, setSaveNotice] = useState<SaveNoticeState | null>(null)
   const promptRequestGeneration = useRef<Record<string, number>>({})
   const runRequestGeneration = useRef<Record<string, number>>({})
-  const runPollControllers = useRef<Set<AbortController>>(new Set())
+  const automationIdsRef = useRef<Set<string>>(new Set())
+  const expandedIdRef = useRef<string | null>(null)
+
+  const automationIdsKey = useMemo(() => automations.map((automation) => automation.id).join("\0"), [automations])
+
+  automationIdsRef.current = new Set(automations.map((automation) => automation.id))
+  expandedIdRef.current = expandedId
 
   const selectedAutomation = useMemo(
     () => editor.mode === "edit" ? automations.find((automation) => automation.id === editor.automationId) ?? null : null,
@@ -109,17 +121,17 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
     }
   }, [client])
 
-  const loadRuns = useCallback(async (automationId: string, signal?: AbortSignal, silent = false) => {
+  const loadRuns = useCallback(async (automationId: string, signal?: AbortSignal, silent = false, limit?: number) => {
     const generation = bumpGeneration(runRequestGeneration, automationId)
-    if (!silent) setDetails((current) => patchDetail(current, automationId, { runsLoading: true }))
+    if (!silent || limit !== undefined) setDetails((current) => patchDetail(current, automationId, { runsLoading: true, runsUnavailable: false }))
     try {
-      const runs = await client.listRuns(automationId, { signal })
+      const runs = await client.listRuns(automationId, { signal, limit })
       if (!isCurrentGeneration(runRequestGeneration, automationId, generation, signal)) return
-      setDetails((current) => patchDetail(current, automationId, { runs, runsLoading: false }))
+      setDetails((current) => patchDetail(current, automationId, { runs, runsLoading: false, runsUnavailable: false }))
     } catch (error) {
       if (!isCurrentGeneration(runRequestGeneration, automationId, generation, signal)) return
       if (!silent) setRouteError(errorMessage(error))
-      setDetails((current) => patchDetail(current, automationId, { runsLoading: false }))
+      setDetails((current) => patchDetail(current, automationId, { runsLoading: false, runsUnavailable: true }))
     }
   }, [client])
 
@@ -129,10 +141,52 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
     return () => controller.abort()
   }, [loadAutomations])
 
-  useEffect(() => () => {
-    for (const controller of runPollControllers.current) controller.abort()
-    runPollControllers.current.clear()
-  }, [])
+  useEffect(() => {
+    if (loading || !automationIdsKey) return
+    const controller = new AbortController()
+    let refreshTimer: ReturnType<typeof setTimeout> | undefined
+    const automationIds = automationIdsKey.split("\0")
+    const refreshRuns = async () => {
+      await Promise.all(automationIds.map((automationId) => (
+        loadRuns(automationId, controller.signal, true, automationId === expandedId ? undefined : 1)
+      )))
+      if (!controller.signal.aborted) refreshTimer = setTimeout(() => void refreshRuns(), RUN_RECONCILE_INTERVAL_MS)
+    }
+    void refreshRuns()
+    return () => {
+      controller.abort()
+      if (refreshTimer !== undefined) clearTimeout(refreshTimer)
+    }
+  }, [automationIdsKey, expandedId, loadRuns, loading])
+
+  useEffect(() => {
+    const controller = new AbortController()
+    let reconnectTimer: ReturnType<typeof setTimeout> | undefined
+    const refreshAutomation = (automationId: string) => {
+      if (!automationIdsRef.current.has(automationId)) return
+      void loadRuns(automationId, controller.signal, true, expandedIdRef.current === automationId ? undefined : 1)
+    }
+    const connect = async () => {
+      try {
+        await client.subscribeRunEvents((event) => {
+          if (event.type === "ready") {
+            for (const automationId of automationIdsRef.current) refreshAutomation(automationId)
+          } else {
+            refreshAutomation(event.event.automationId)
+          }
+        }, { signal: controller.signal })
+      } catch (error) {
+        if (error instanceof AutomationClientError && (error.statusCode === 401 || error.statusCode === 403)) return
+        // Reconnect below; durable state is reconciled independently as a fallback.
+      }
+      if (!controller.signal.aborted) reconnectTimer = setTimeout(() => void connect(), RUN_STREAM_RECONNECT_MS)
+    }
+    void connect()
+    return () => {
+      controller.abort()
+      if (reconnectTimer !== undefined) clearTimeout(reconnectTimer)
+    }
+  }, [client, loadRuns])
 
   const openCreate = useCallback(() => {
     setEditor({ mode: "create" })
@@ -148,11 +202,9 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
   }, [loadPrompt])
 
   const toggleExpanded = useCallback((automation: Automation) => {
-    const willExpand = expandedId !== automation.id
-    setExpandedId(willExpand ? automation.id : null)
+    setExpandedId(expandedId !== automation.id ? automation.id : null)
     setShellError(null)
-    if (willExpand) void loadRuns(automation.id)
-  }, [expandedId, loadRuns])
+  }, [expandedId])
 
   async function refreshAutomationAndPrompt(automationId: string) {
     const generation = bumpGeneration(promptRequestGeneration, automationId)
@@ -233,6 +285,26 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
     }
   }
 
+  async function toggleEnabled(automation: Automation) {
+    if (togglingEnabledIds.has(automation.id)) return
+    setTogglingEnabledIds((current) => new Set(current).add(automation.id))
+    setRouteError(null)
+    setSaveNotice(null)
+    try {
+      const updated = await client.updateAutomation(automation.id, { enabled: !automation.enabled })
+      setAutomations((current) => current.map((item) => item.id === updated.id ? updated : item))
+      setSaveNotice({ tone: "success", message: updated.enabled ? "Automation resumed." : "Automation paused." })
+    } catch (error) {
+      setRouteError(errorMessage(error))
+    } finally {
+      setTogglingEnabledIds((current) => {
+        const next = new Set(current)
+        next.delete(automation.id)
+        return next
+      })
+    }
+  }
+
   async function runNow(automation: Automation) {
     if (runningNowIds.has(automation.id)) return
     bumpGeneration(runRequestGeneration, automation.id)
@@ -241,17 +313,6 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
     setSaveNotice(null)
     setExpandedId(automation.id)
     const runRequest = client.runNow(automation.id)
-    const pollController = new AbortController()
-    runPollControllers.current.add(pollController)
-    let runPoll: ReturnType<typeof setTimeout> | undefined
-    const clearRunPoll = () => { if (runPoll !== undefined) clearTimeout(runPoll) }
-    pollController.signal.addEventListener("abort", clearRunPoll, { once: true })
-    const pollRuns = async () => {
-      if (pollController.signal.aborted) return
-      await loadRuns(automation.id, pollController.signal, true)
-      if (!pollController.signal.aborted) runPoll = setTimeout(() => void pollRuns(), 1_000)
-    }
-    void pollRuns()
     try {
       const run = await runRequest
       bumpGeneration(runRequestGeneration, automation.id)
@@ -271,13 +332,9 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
         ? { tone: "warning", message: refreshWarning }
         : { tone: "success", message: run.sessionId ? "Automation finished. Open its session from run history." : "Automation finished." })
     } catch (error) {
-      pollController.abort()
       setRouteError(errorMessage(error))
       await loadRuns(automation.id)
     } finally {
-      pollController.abort()
-      pollController.signal.removeEventListener("abort", clearRunPoll)
-      runPollControllers.current.delete(pollController)
       setRunningNowIds((current) => {
         const next = new Set(current)
         next.delete(automation.id)
@@ -316,11 +373,11 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
           </div>
         </div>
         <div className="flex shrink-0 items-center justify-end gap-1" style={{ flex: "1 1 16rem" }}>
-          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={() => void loadAutomations()} disabled={loading || editor.mode !== "closed"}>
+          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" variant="ghost" size="sm" onClick={() => void loadAutomations()} disabled={loading || editor.mode !== "closed" || togglingEnabledIds.size > 0}>
             <RefreshCw className="size-4" aria-hidden="true" />
             Refresh
           </Button>
-          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" size="sm" onClick={openCreate}>
+          <Button className="text-[13px]" style={{ minHeight: compactControls ? 32 : 44 }} type="button" size="sm" onClick={openCreate} disabled={togglingEnabledIds.size > 0}>
             <Plus className="size-4" aria-hidden="true" />
             New
           </Button>
@@ -357,10 +414,13 @@ export function AutomationPanel({ onClose }: { onClose?: () => void }) {
                       deleting={deleteId === automation.id}
                       runs={detail?.runs ?? []}
                       runsLoading={detail?.runsLoading === true}
+                      runsUnavailable={detail?.runsUnavailable === true}
                       runningNow={runningNowIds.has(automation.id)}
+                      togglingEnabled={togglingEnabledIds.has(automation.id)}
                       onToggle={() => toggleExpanded(automation)}
                       onEdit={() => openEdit(automation)}
                       onRunNow={() => void runNow(automation)}
+                      onToggleEnabled={() => void toggleEnabled(automation)}
                       onOpenPrompt={() => openPrompt(automation)}
                       onDeleteRequest={() => setDeleteId(automation.id)}
                       onDeleteCancel={() => setDeleteId(null)}
diff --git a/plugins/boring-automation/src/front/__tests__/AutomationPanel.test.tsx b/plugins/boring-automation/src/front/__tests__/AutomationPanel.test.tsx
index 39ebc1440..6d0d99311 100644
--- a/plugins/boring-automation/src/front/__tests__/AutomationPanel.test.tsx
+++ b/plugins/boring-automation/src/front/__tests__/AutomationPanel.test.tsx
@@ -59,6 +59,9 @@ function automationRun(overrides: Partial<AutomationRun> = {}): AutomationRun {
 
 function createClient(overrides: Partial<Record<keyof AutomationClient, ReturnType<typeof vi.fn>>> = {}) {
   return {
+    subscribeRunEvents: vi.fn((_listener, options: { signal?: AbortSignal } = {}) => new Promise<void>((resolve) => {
+      options.signal?.addEventListener("abort", () => resolve(), { once: true })
+    })),
     listAutomations: vi.fn(async () => []),
     createAutomation: vi.fn(async (input) => automation({ ...input, id: "created-1" })),
     getAutomation: vi.fn(async (id) => automation({ id })),
@@ -104,6 +107,7 @@ beforeEach(() => {
 
 afterEach(() => {
   cleanup()
+  vi.useRealTimers()
   vi.clearAllMocks()
   vi.unstubAllGlobals()
 })
@@ -134,6 +138,59 @@ describe("AutomationPanel", () => {
     expect(title.closest("button")).toHaveAccessibleName(/Paused/)
   })
 
+  it("shows the last run status and pauses or resumes from the card", async () => {
+    const existing = automation()
+    const update = deferred<Automation>()
+    const client = createClient({
+      listAutomations: vi.fn(async () => [existing]),
+      listRuns: vi.fn(async () => [automationRun({ status: "failed" })]),
+      updateAutomation: vi.fn(() => update.promise),
+    })
+
+    renderPanel(client)
+
+    expect(await screen.findByLabelText("Last run Failed")).toBeInTheDocument()
+    expect(client.listRuns).toHaveBeenCalledWith(existing.id, expect.objectContaining({ limit: 1 }))
+    const pauseButton = screen.getByRole("button", { name: `Pause ${existing.title}` })
+    fireEvent.click(pauseButton)
+    expect(pauseButton).toBeDisabled()
+    expect(screen.getByRole("button", { name: `Run ${existing.title} now` })).toBeDisabled()
+    expect(screen.getByRole("button", { name: `Open prompt for ${existing.title}` })).toBeDisabled()
+    expect(screen.getByRole("button", { name: "Edit" })).toBeDisabled()
+    expect(screen.getByRole("button", { name: `Delete ${existing.title}` })).toBeDisabled()
+    expect(screen.getByRole("button", { name: "Refresh" })).toBeDisabled()
+    expect(screen.getByRole("button", { name: "New" })).toBeDisabled()
+    expect(client.updateAutomation).toHaveBeenCalledWith(existing.id, { enabled: false })
+
+    await act(async () => update.resolve(automation({ enabled: false })))
+
+    expect(await screen.findByRole("button", { name: `Resume ${existing.title}` })).toBeInTheDocument()
+    expect(screen.getByRole("status")).toHaveTextContent("Automation paused.")
+  })
+
+  it("refreshes scheduled run status from server events while the panel stays open", async () => {
+    const existing = automation()
+    let emit!: (event: { type: "run.changed"; event: { automationId: string } }) => void
+    const client = createClient({
+      listAutomations: vi.fn(async () => [existing]),
+      listRuns: vi.fn()
+        .mockResolvedValueOnce([automationRun({ status: "running", completedAt: null })])
+        .mockResolvedValue([automationRun({ status: "succeeded" })]),
+      subscribeRunEvents: vi.fn((listener, options: { signal?: AbortSignal } = {}) => {
+        emit = listener
+        return new Promise<void>((resolve) => options.signal?.addEventListener("abort", () => resolve(), { once: true }))
+      }),
+    })
+
+    renderPanel(client)
+    expect(await screen.findByLabelText("Last run Running")).toBeInTheDocument()
+
+    act(() => emit({ type: "run.changed", event: { automationId: existing.id } }))
+
+    expect(await screen.findByLabelText("Last run Succeeded")).toBeInTheDocument()
+    expect(client.listRuns).toHaveBeenCalledTimes(2)
+  })
+
   it("shows accessible route errors", async () => {
     const client = createClient({ listAutomations: vi.fn(async () => { throw new Error("list failed") }) })
 
@@ -432,15 +489,15 @@ describe("AutomationPanel", () => {
 
     expect(runButton).toBeDisabled()
     expect(client.runNow).toHaveBeenCalledTimes(1)
-    expect(await screen.findByText("Running", { exact: true })).toBeInTheDocument()
+    expect(await screen.findByLabelText("Last run Running")).toBeInTheDocument()
     expect(screen.getByLabelText("Open session session-1")).toBeEnabled()
-    expect(screen.getByText("Succeeded")).toBeInTheDocument()
+    expect(screen.getAllByText("Succeeded").length).toBeGreaterThan(0)
 
     await act(async () => pending.resolve(run))
 
     expect(await screen.findByText("Automation finished. Open its session from run history.")).toBeInTheDocument()
     expect(shellState.current!.refreshChatSessions).toHaveBeenCalledOnce()
-    expect(screen.getAllByText("Succeeded")).toHaveLength(2)
+    expect(screen.getAllByText("Succeeded")).toHaveLength(3)
     expect(runButton).not.toBeDisabled()
   })
 
@@ -458,7 +515,7 @@ describe("AutomationPanel", () => {
     fireEvent.click(runButton)
 
     expect(await screen.findByText("Automation finished, but chat history could not be refreshed: history unavailable")).toBeInTheDocument()
-    expect(screen.getByText("Succeeded")).toBeInTheDocument()
+    expect(screen.getByLabelText("Last run Succeeded")).toBeInTheDocument()
     expect(screen.queryByRole("alert")).not.toBeInTheDocument()
     await waitFor(() => expect(runButton).not.toBeDisabled())
   })
@@ -474,7 +531,7 @@ describe("AutomationPanel", () => {
     await screen.findByText(existing.title)
     fireEvent.click(screen.getByRole("button", { name: `Run ${existing.title} now` }))
 
-    expect(await screen.findByText("Failed")).toBeInTheDocument()
+    expect(await screen.findByLabelText("Last run Failed")).toBeInTheDocument()
     expect(shellState.current!.refreshChatSessions).not.toHaveBeenCalled()
   })
 
@@ -491,15 +548,15 @@ describe("AutomationPanel", () => {
     renderPanel(client)
     await screen.findByText(existing.title)
     fireEvent.click(screen.getByRole("button", { name: `Run ${existing.title} now` }))
-    expect(client.listRuns).toHaveBeenCalledTimes(1)
+    expect(client.listRuns).toHaveBeenCalledTimes(2)
 
     await act(async () => pending.resolve(automationRun()))
-    expect(await screen.findByText("Succeeded")).toBeInTheDocument()
+    expect(await screen.findByLabelText("Last run Succeeded")).toBeInTheDocument()
 
     await act(async () => history.resolve([automationRun({ id: "stale-run", status: "failed" })]))
     await waitFor(() => {
       expect(screen.queryByText("Failed")).not.toBeInTheDocument()
-      expect(screen.getByText("Succeeded")).toBeInTheDocument()
+      expect(screen.getByLabelText("Last run Succeeded")).toBeInTheDocument()
     })
   })
 
diff --git a/plugins/boring-automation/src/front/__tests__/client.test.ts b/plugins/boring-automation/src/front/__tests__/client.test.ts
index eda10c421..fa6f75005 100644
--- a/plugins/boring-automation/src/front/__tests__/client.test.ts
+++ b/plugins/boring-automation/src/front/__tests__/client.test.ts
@@ -46,6 +46,39 @@ describe("automation front client", () => {
     expect(fetchMock.mock.calls[0]?.[1]?.body).toBeUndefined()
   })
 
+  it("streams authenticated run invalidations across split SSE frames", async () => {
+    const encoder = new TextEncoder()
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode("event: ready\r\ndata: {\"v\":1}\r\n\r"))
+        controller.enqueue(encoder.encode("\nevent: run.changed\ndata: {\"v\":1,\"eventId\":\"e1\",\"workspaceId\":\"w1\",\"userId\":\"u1\",\"automationId\":\"a1\",\"runId\":\"r1\",\"status\":\"succeeded\",\"updatedAt\":\"now\"}\n\n"))
+        controller.close()
+      },
+    })
+    const fetchMock = vi.fn<typeof fetch>(async () => new Response(body, { status: 200 }))
+    vi.stubGlobal("fetch", fetchMock)
+    const events: unknown[] = []
+
+    await createAutomationClient({ headers: { Authorization: "Bearer test" } }).subscribeRunEvents((event) => events.push(event))
+
+    expect(fetchMock).toHaveBeenCalledWith(`${BORING_AUTOMATION_ROUTE_PREFIX}/events`, expect.objectContaining({
+      headers: expect.objectContaining({ Accept: "text/event-stream", Authorization: "Bearer test" }),
+    }))
+    expect(events).toEqual([
+      { type: "ready" },
+      { type: "run.changed", event: expect.objectContaining({ automationId: "a1", runId: "r1", status: "succeeded" }) },
+    ])
+  })
+
+  it("requests only the latest run when a history limit is provided", async () => {
+    const fetchMock = vi.fn<typeof fetch>(async () => Response.json({ ok: true, runs: [] }))
+    vi.stubGlobal("fetch", fetchMock)
+
+    await createAutomationClient().listRuns("a1", { limit: 1 })
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/a1/runs?limit=1`)
+  })
+
   it("does not apply the short UI timeout to a long-running automation request", async () => {
     vi.useFakeTimers()
     let resolveFetch!: (response: Response) => void
diff --git a/plugins/boring-automation/src/front/client.ts b/plugins/boring-automation/src/front/client.ts
index 909f13441..0f458b65c 100644
--- a/plugins/boring-automation/src/front/client.ts
+++ b/plugins/boring-automation/src/front/client.ts
@@ -1,4 +1,4 @@
-import { BORING_AUTOMATION_ROUTE_PREFIX, type Automation, type AutomationCreate, type AutomationPatch, type AutomationRun } from "../shared"
+import { BORING_AUTOMATION_ROUTE_PREFIX, type Automation, type AutomationCreate, type AutomationPatch, type AutomationRun, type AutomationRunChangedEvent } from "../shared"
 
 export class AutomationClientError extends Error {
   constructor(
@@ -20,8 +20,13 @@ export interface AutomationClientOptions {
 
 export interface AutomationClientRequestOptions {
   signal?: AbortSignal
+  limit?: number
 }
 
+export type AutomationRunStreamEvent =
+  | { type: "ready" }
+  | { type: "run.changed"; event: AutomationRunChangedEvent }
+
 type ApiOk<T> = T & { ok: true }
 type ApiError = { ok?: false; code?: string; error?: string }
 
@@ -111,6 +116,38 @@ export function createAutomationClient(options: AutomationClientOptions = {}) {
   }
 
   return {
+    async subscribeRunEvents(onEvent: (event: AutomationRunStreamEvent) => void, requestOptions: AutomationClientRequestOptions = {}): Promise<void> {
+      const response = await fetch(joinUrl(options.apiBaseUrl, `${BORING_AUTOMATION_ROUTE_PREFIX}/events`), {
+        headers: { Accept: "text/event-stream", ...(options.headers ?? {}) },
+        signal: requestOptions.signal,
+      })
+      if (!response.ok) {
+        if (response.status === 401 || response.status === 403) options.onAuthError?.(response.status)
+        throw new AutomationClientError("BORING_AUTOMATION_EVENT_STREAM_ERROR", "Automation event stream failed", response.status)
+      }
+      if (!response.body) throw new AutomationClientError("BORING_AUTOMATION_EVENT_STREAM_ERROR", "Automation event stream is unavailable", response.status)
+
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ""
+      try {
+        while (true) {
+          const next = await reader.read()
+          if (next.done) break
+          buffer += decoder.decode(next.value, { stream: true })
+          buffer = buffer.replace(/\r\n/g, "\n")
+          const frames = buffer.split("\n\n")
+          buffer = frames.pop() ?? ""
+          for (const frame of frames) {
+            const parsed = parseRunStreamFrame(frame)
+            if (parsed) onEvent(parsed)
+          }
+        }
+      } finally {
+        reader.releaseLock()
+      }
+    },
+
     async listAutomations(requestOptions: AutomationClientRequestOptions = {}): Promise<Automation[]> {
       const payload = await request<{ automations: Automation[] }>("/automations", { signal: requestOptions.signal })
       return payload.automations
@@ -159,10 +196,27 @@ export function createAutomationClient(options: AutomationClientOptions = {}) {
     },
 
     async listRuns(id: string, requestOptions: AutomationClientRequestOptions = {}): Promise<AutomationRun[]> {
-      const payload = await request<{ runs: AutomationRun[] }>(`/automations/${encodeURIComponent(id)}/runs`, { signal: requestOptions.signal })
+      const query = requestOptions.limit === undefined ? "" : `?limit=${encodeURIComponent(String(requestOptions.limit))}`
+      const payload = await request<{ runs: AutomationRun[] }>(`/automations/${encodeURIComponent(id)}/runs${query}`, { signal: requestOptions.signal })
       return payload.runs
     },
   }
 }
 
+function parseRunStreamFrame(frame: string): AutomationRunStreamEvent | null {
+  let eventType = "message"
+  const data: string[] = []
+  for (const line of frame.split("\n")) {
+    if (line.startsWith("event:")) eventType = line.slice(6).trim()
+    if (line.startsWith("data:")) data.push(line.slice(5).trimStart())
+  }
+  if (eventType === "ready") return { type: "ready" }
+  if (eventType !== "run.changed" || data.length === 0) return null
+  try {
+    return { type: "run.changed", event: JSON.parse(data.join("\n")) as AutomationRunChangedEvent }
+  } catch {
+    return null
+  }
+}
+
 export type AutomationClient = ReturnType<typeof createAutomationClient>
diff --git a/plugins/boring-automation/src/server/__tests__/fileStore.test.ts b/plugins/boring-automation/src/server/__tests__/fileStore.test.ts
index 158d70b50..31ae29fec 100644
--- a/plugins/boring-automation/src/server/__tests__/fileStore.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/fileStore.test.ts
@@ -122,6 +122,32 @@ describe("FileAutomationStore persistence", () => {
       expect.objectContaining({ id: orphan.id, status: "failed", completedAt: "2026-07-10T00:10:00.000Z", durationMs: 599_000, error: "Automation host restarted before the run completed" }),
       expect.objectContaining({ id: replacement.id, status: "queued" }),
     ]))
+    await expect(restartedStore.listRuns(automation.id, 1)).resolves.toHaveLength(1)
+  })
+
+  it("allows only one dispatcher to claim a queued run", async () => {
+    const store = createStore()
+    const automation = await store.createAutomation({
+      title: "Claim once", cron: "0 9 * * *", timezone: "UTC", model: "test:model", prompt: "run",
+    })
+    const run = await store.beginRun({
+      automationId: automation.id,
+      invocationId: "scheduled:claim-once",
+      trigger: "scheduled",
+      scheduledFor: "2026-07-10T09:00:00.000Z",
+      promptSnapshot: "run",
+      modelSnapshot: "test:model",
+    })
+
+    const claims = await Promise.all([
+      store.claimRunForDispatch(run.id),
+      store.claimRunForDispatch(run.id),
+    ])
+
+    expect(claims.filter((claim) => claim !== null)).toHaveLength(1)
+    await expect(store.listRuns(automation.id)).resolves.toEqual([
+      expect.objectContaining({ id: run.id, status: "dispatching" }),
+    ])
   })
 
   it("leaves a recoverable orphan prompt and unchanged live cache when the metadata commit fails", async () => {
diff --git a/plugins/boring-automation/src/server/__tests__/hostedDueCoordinator.test.ts b/plugins/boring-automation/src/server/__tests__/hostedDueCoordinator.test.ts
new file mode 100644
index 000000000..cb439c9d8
--- /dev/null
+++ b/plugins/boring-automation/src/server/__tests__/hostedDueCoordinator.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it, vi } from "vitest"
+import { HostedDueCoordinator } from "../hostedDueCoordinator"
+import type { HostedDueRunResult } from "../hostedDueRunService"
+
+const RESULT: HostedDueRunResult = {
+  now: "2026-07-23T09:00:00.000Z",
+  outcomes: [],
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((next) => { resolve = next })
+  return { promise, resolve }
+}
+
+describe("HostedDueCoordinator", () => {
+  it("shares one due evaluation across overlapping timer and HTTP wake-ups", async () => {
+    const first = deferred<HostedDueRunResult>()
+    const runDue = vi.fn()
+      .mockImplementationOnce(async () => await first.promise)
+      .mockResolvedValue(RESULT)
+    const coordinator = new HostedDueCoordinator({ runDue })
+    const request = { id: "request-1" } as never
+
+    const timerRun = coordinator.runDue()
+    const endpointRun = coordinator.runDue(request)
+    expect(runDue).toHaveBeenCalledOnce()
+    expect(endpointRun).toBe(timerRun)
+
+    first.resolve(RESULT)
+    await expect(Promise.all([timerRun, endpointRun])).resolves.toEqual([RESULT, RESULT])
+
+    await expect(coordinator.runDue(request)).resolves.toEqual(RESULT)
+    expect(runDue).toHaveBeenCalledTimes(2)
+    expect(runDue).toHaveBeenLastCalledWith(request)
+  })
+
+  it("clears rejected evaluations so later ticks can retry", async () => {
+    const runDue = vi.fn()
+      .mockRejectedValueOnce(new Error("temporary"))
+      .mockResolvedValue(RESULT)
+    const coordinator = new HostedDueCoordinator({ runDue })
+
+    await expect(coordinator.runDue()).rejects.toThrow("temporary")
+    await expect(coordinator.runDue()).resolves.toEqual(RESULT)
+    expect(runDue).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/plugins/boring-automation/src/server/__tests__/hostedDueRunService.test.ts b/plugins/boring-automation/src/server/__tests__/hostedDueRunService.test.ts
new file mode 100644
index 000000000..34c9202a4
--- /dev/null
+++ b/plugins/boring-automation/src/server/__tests__/hostedDueRunService.test.ts
@@ -0,0 +1,204 @@
+import type postgres from "postgres"
+import { describe, expect, it, vi } from "vitest"
+import { BORING_AUTOMATION_ERROR_CODES } from "../../shared"
+import { HostedDueRunService } from "../hostedDueRunService"
+
+const AUTOMATION_ROW = {
+  id: "automation-a",
+  workspace_id: "workspace-a",
+  owner_user_id: "user-a",
+  title: "Daily",
+  enabled: true,
+  cron: "0 9 * * *",
+  timezone: "UTC",
+  model: "test:model-a",
+  created_at: "2026-07-23T08:00:00.000Z",
+  updated_at: "2026-07-23T08:00:00.000Z",
+}
+
+const RUN_ROW = {
+  id: "run-a",
+  automation_id: "automation-a",
+  session_id: null,
+  status: "queued",
+  trigger: "scheduled",
+  scheduled_for: "2026-07-23T09:00:00.000Z",
+  started_at: null,
+  completed_at: null,
+  duration_ms: null,
+  input_tokens: null,
+  output_tokens: null,
+  total_tokens: null,
+  prompt_snapshot: "Run",
+  model_snapshot: "test:model-a",
+  error: null,
+  created_at: "2026-07-23T09:00:15.000Z",
+  updated_at: "2026-07-23T09:00:15.000Z",
+}
+
+type MutableRunRow = Omit<typeof RUN_ROW, "session_id" | "started_at" | "completed_at" | "duration_ms"> & {
+  session_id: string | null
+  started_at: string | null
+  completed_at: string | null
+  duration_ms: number | null
+}
+
+function uniqueRaceSql(constraintName: string): postgres.Sql {
+  return (async (strings: TemplateStringsArray) => {
+    const text = strings.join("?")
+    if (text.includes("INSERT INTO boring_automation_runs")) {
+      throw Object.assign(new Error("unique violation"), { code: "23505", constraint_name: constraintName })
+    }
+    if (text.includes("SELECT prompt")) return [{ prompt: "Run" }]
+    if (text.includes("FROM boring_automation_automations")) return [AUTOMATION_ROW]
+    return []
+  }) as unknown as postgres.Sql
+}
+
+describe("HostedDueRunService", () => {
+  it("rejects an unauthorized creator before actor-scoped execution", async () => {
+    const queries: string[] = []
+    const sql = (async (strings: TemplateStringsArray) => {
+      const text = strings.join("?")
+      queries.push(text)
+      return text.includes("FROM boring_automation_automations") ? [AUTOMATION_ROW] : []
+    }) as unknown as postgres.Sql
+    const resolve = vi.fn()
+    const verifyActor = vi.fn(() => false)
+    const service = new HostedDueRunService({
+      sql,
+      dispatcherResolver: { resolve } as never,
+      verifyActor,
+      clock: () => new Date("2026-07-23T09:00:15.000Z"),
+    })
+
+    const result = await service.runDue()
+
+    expect(verifyActor).toHaveBeenCalledWith({ workspaceId: "workspace-a", userId: "user-a" })
+    expect(result.outcomes).toEqual([expect.objectContaining({
+      kind: "failed",
+      code: BORING_AUTOMATION_ERROR_CODES.OWNER_UNAUTHORIZED,
+    })])
+    expect(resolve).not.toHaveBeenCalled()
+    expect(queries).toHaveLength(3)
+    expect(queries[0]).toContain("updated_at <")
+  })
+
+  it("executes a verified creator internally without fabricating a request", async () => {
+    let runRow: MutableRunRow = { ...RUN_ROW }
+    let lifecycleUpdates = 0
+    const sql = Object.assign((async (strings: TemplateStringsArray) => {
+      const text = strings.join("?")
+      if (text.includes("INSERT INTO boring_automation_runs")) return [runRow]
+      if (text.includes("SELECT * FROM boring_automation_runs")) return [runRow]
+      if (text.includes("updated_at <")) return []
+      if (text.includes("UPDATE boring_automation_runs")) {
+        lifecycleUpdates += 1
+        runRow = lifecycleUpdates === 1
+          ? { ...runRow, status: "running", started_at: "2026-07-23T09:00:15.000Z" }
+          : lifecycleUpdates === 2
+            ? { ...runRow, session_id: "session-1" }
+            : { ...runRow, status: "succeeded", completed_at: "2026-07-23T09:00:16.000Z", duration_ms: 1_000 }
+        return [runRow]
+      }
+      if (text.includes("FROM boring_automation_automations")) return [AUTOMATION_ROW]
+      return []
+    }), { json: (value: unknown) => value }) as unknown as postgres.Sql
+    const dispatch = vi.fn(async (input: { requestId: string }) => ({
+      ref: { agentTypeId: "default", sessionId: "session-1" },
+      receipt: { accepted: true as const, cursor: 0, disposition: "prompt" as const, clientNonce: input.requestId },
+      events: (async function* () {})(),
+    }))
+    const dispatcher = { dispatch }
+    const workspace = { readFile: vi.fn(async () => "Run") }
+    const resolve = vi.fn(async () => dispatcher)
+    const resolveWithWorkspace = vi.fn(async () => ({ dispatcher, workspace }))
+    const verifyActor = vi.fn(() => true)
+    const service = new HostedDueRunService({
+      sql,
+      dispatcherResolver: { resolve, resolveWithWorkspace } as never,
+      verifyActor,
+      clock: () => new Date("2026-07-23T09:00:15.000Z"),
+    })
+
+    const result = await service.runDue()
+
+    const actor = { workspaceId: "workspace-a", userId: "user-a" }
+    expect(verifyActor).toHaveBeenCalledWith(actor)
+    expect(resolveWithWorkspace).toHaveBeenCalledWith(actor, { request: undefined })
+    expect(resolve).toHaveBeenCalledWith(actor, undefined)
+    expect(dispatch).toHaveBeenCalledOnce()
+    expect(workspace.readFile).toHaveBeenCalledOnce()
+    expect(result.outcomes).toEqual([expect.objectContaining({
+      kind: "started",
+      automationId: "automation-a",
+      scheduledFor: "2026-07-23T09:00:00.000Z",
+      run: expect.objectContaining({ status: "succeeded", sessionId: "session-1" }),
+    })])
+  })
+
+  it("reconciles stale hosted runs before evaluating new schedule work", async () => {
+    const publish = vi.fn(async () => undefined)
+    const resolve = vi.fn()
+    const sql = (async (strings: TemplateStringsArray) => {
+      const text = strings.join("?")
+      if (text.includes("updated_at <")) return [{
+        ...RUN_ROW,
+        workspace_id: "workspace-a",
+        owner_user_id: "user-a",
+        invocation_id: "scheduled:stale",
+        dispatch_request_id: "run-a",
+        dispatch_receipt: null,
+        status: "failed",
+        completed_at: "2026-07-23T09:00:15.000Z",
+        error: "Automation worker lease expired before the run completed",
+      }]
+      if (text.includes("FROM boring_automation_automations")) return [{ ...AUTOMATION_ROW, enabled: false }]
+      return []
+    }) as unknown as postgres.Sql
+    const service = new HostedDueRunService({
+      sql,
+      dispatcherResolver: { resolve } as never,
+      verifyActor: vi.fn(() => true),
+      eventPublisher: { publish },
+      clock: () => new Date("2026-07-23T09:00:15.000Z"),
+    })
+
+    await service.runDue()
+
+    expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+      workspaceId: "workspace-a",
+      userId: "user-a",
+      runId: "run-a",
+      status: "failed",
+    }))
+    expect(resolve).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    ["boring_automation_runs_active_once_idx", "active-run"],
+    ["boring_automation_runs_scheduled_once_idx", "duplicate-scheduled-run"],
+  ])("reports %s cross-process races as skips", async (constraintName, reason) => {
+    const resolve = vi.fn()
+    const resolveWithWorkspace = vi.fn(async () => ({
+      dispatcher: {},
+      workspace: { readFile: vi.fn(async () => "Run") },
+    }))
+    const service = new HostedDueRunService({
+      sql: uniqueRaceSql(constraintName),
+      dispatcherResolver: { resolve, resolveWithWorkspace } as never,
+      verifyActor: vi.fn(() => true),
+      clock: () => new Date("2026-07-23T09:00:15.000Z"),
+    })
+
+    const result = await service.runDue()
+
+    expect(result.outcomes).toEqual([expect.objectContaining({
+      kind: "skipped",
+      automationId: "automation-a",
+      scheduledFor: "2026-07-23T09:00:00.000Z",
+      reason,
+    })])
+    expect(resolve).not.toHaveBeenCalled()
+  })
+})
diff --git a/plugins/boring-automation/src/server/__tests__/hostedScheduler.test.ts b/plugins/boring-automation/src/server/__tests__/hostedScheduler.test.ts
new file mode 100644
index 000000000..d2bfb5fe9
--- /dev/null
+++ b/plugins/boring-automation/src/server/__tests__/hostedScheduler.test.ts
@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from "vitest"
+import { HostedAutomationScheduler } from "../hostedScheduler"
+import type { HostedDueRunResult } from "../hostedDueRunService"
+
+const EMPTY_RESULT: HostedDueRunResult = {
+  now: "2026-07-23T09:00:00.000Z",
+  outcomes: [],
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((next) => { resolve = next })
+  return { promise, resolve }
+}
+
+function logger() {
+  return {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }
+}
+
+describe("HostedAutomationScheduler", () => {
+  it("uses Croner to wake again at the next minute", async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date("2026-07-23T09:00:30.000Z"))
+    const runDue = vi.fn(async () => EMPTY_RESULT)
+    const scheduler = new HostedAutomationScheduler({ runDue, logger: logger() as never })
+    try {
+      scheduler.start()
+      expect(runDue).toHaveBeenCalledOnce()
+
+      await vi.advanceTimersByTimeAsync(30_000)
+      expect(runDue).toHaveBeenCalledTimes(2)
+    } finally {
+      scheduler.beginShutdown()
+      vi.useRealTimers()
+    }
+  })
+
+  it("ticks at startup, prevents overlap, and stops the Croner job", async () => {
+    const first = deferred<HostedDueRunResult>()
+    const runDue = vi.fn()
+      .mockImplementationOnce(async () => await first.promise)
+      .mockResolvedValue(EMPTY_RESULT)
+    const log = logger()
+    const stop = vi.fn()
+    let scheduledTick: (() => Promise<void>) | undefined
+    const scheduleCron = vi.fn((tick: () => Promise<void>) => {
+      scheduledTick = tick
+      return { stop }
+    })
+    const scheduler = new HostedAutomationScheduler({ runDue, logger: log as never, scheduleCron })
+
+    scheduler.start()
+    expect(scheduleCron).toHaveBeenCalledOnce()
+    expect(runDue).toHaveBeenCalledOnce()
+
+    await scheduledTick!()
+    expect(runDue).toHaveBeenCalledOnce()
+
+    first.resolve(EMPTY_RESULT)
+    await vi.waitFor(() => expect(log.debug).toHaveBeenCalledOnce())
+    await scheduledTick!()
+    expect(runDue).toHaveBeenCalledTimes(2)
+
+    scheduler.beginShutdown()
+    expect(stop).toHaveBeenCalledOnce()
+    await scheduledTick!()
+    expect(runDue).toHaveBeenCalledTimes(2)
+  })
+
+  it("sanitizes tick failures and continues on the next minute", async () => {
+    const runDue = vi.fn()
+      .mockRejectedValueOnce(new Error("postgres://user:secret@example.test/private"))
+      .mockResolvedValue(EMPTY_RESULT)
+    const log = logger()
+    let scheduledTick: (() => Promise<void>) | undefined
+    const scheduler = new HostedAutomationScheduler({
+      runDue,
+      logger: log as never,
+      scheduleCron: (tick) => {
+        scheduledTick = tick
+        return { stop: vi.fn() }
+      },
+    })
+
+    scheduler.start()
+    await vi.waitFor(() => expect(log.error).toHaveBeenCalledOnce())
+    expect(log.error.mock.calls[0]?.[0]).toEqual({
+      automationScheduler: { event: "tick-failed", errorName: "Error" },
+    })
+    expect(JSON.stringify(log.error.mock.calls)).not.toContain("secret")
+
+    await scheduledTick!()
+    expect(runDue).toHaveBeenCalledTimes(2)
+    expect(log.debug).toHaveBeenCalledOnce()
+    scheduler.beginShutdown()
+  })
+
+  it("fences future ticks without waiting for an active durable run", async () => {
+    const active = deferred<HostedDueRunResult>()
+    const stopJob = vi.fn()
+    const completed = vi.fn()
+    const scheduler = new HostedAutomationScheduler({
+      runDue: async () => {
+        const result = await active.promise
+        completed()
+        return result
+      },
+      logger: logger() as never,
+      scheduleCron: () => ({ stop: stopJob }),
+    })
+    scheduler.start()
+
+    scheduler.beginShutdown()
+    expect(stopJob).toHaveBeenCalledOnce()
+    expect(completed).not.toHaveBeenCalled()
+
+    active.resolve(EMPTY_RESULT)
+    await vi.waitFor(() => expect(completed).toHaveBeenCalledOnce())
+  })
+})
diff --git a/plugins/boring-automation/src/server/__tests__/manualRunExecutor.test.ts b/plugins/boring-automation/src/server/__tests__/manualRunExecutor.test.ts
index ffdf4118f..e24041368 100644
--- a/plugins/boring-automation/src/server/__tests__/manualRunExecutor.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/manualRunExecutor.test.ts
@@ -2,11 +2,24 @@ import type { FastifyRequest } from "fastify"
 import type { AgentEvent } from "@hachej/boring-agent/shared"
 import type { WorkspaceAgentDispatcher } from "@hachej/boring-agent/shared"
 import type { WorkspaceAgentDispatcherResolver } from "@hachej/boring-agent/server"
-import { describe, expect, it, vi } from "vitest"
+import { afterEach, describe, expect, it, vi } from "vitest"
 import { BORING_AUTOMATION_ERROR_CODES } from "../../shared/error-codes"
 import type { Automation, AutomationCreate, AutomationPatch, AutomationRun, AutomationRunBegin, AutomationRunLifecyclePatch } from "../../shared/types"
-import { ManualRunExecutor, parseAutomationModel, type VerifiedAutomationActor } from "../manualRunExecutor"
-import { AutomationStoreError, type AutomationStore, automationNotFound, runNotFound } from "../store"
+import { automationSessionTitle, ManualRunExecutor, parseAutomationModel, type VerifiedAutomationActor } from "../manualRunExecutor"
+import type { AutomationRunEventPublisher } from "../runEventBus"
+import { AutomationStoreError, type AutomationStore, automationNotFound, runLeaseLost, runNotFound } from "../store"
+
+afterEach(() => vi.useRealTimers())
+
+describe("automationSessionTitle", () => {
+  it("prefixes the prompt-derived session name with its automation title", () => {
+    expect(automationSessionTitle("Daily summary", "  Summarize sales\nInclude a chart  ")).toBe(
+      "Automation Daily summary: Summarize sales",
+    )
+    expect(automationSessionTitle("Daily summary", "  ")).toBe("Automation Daily summary: Run")
+    expect(automationSessionTitle("Daily summary", "x".repeat(100))).toHaveLength(80)
+  })
+})
 
 describe("parseAutomationModel", () => {
   it("parses explicit provider:model-id syntax and splits on the first colon", () => {
@@ -68,11 +81,60 @@ describe("ManualRunExecutor", () => {
     })
     expect(harness.dispatcher.dispatch).toHaveBeenCalledWith(expect.objectContaining({
       requestId: run.id,
+      title: "Automation Daily summary: canonical prompt",
       content: "canonical prompt",
       model: { provider: "anthropic", id: "claude-sonnet" },
     }))
   })
 
+  it("publishes durable lifecycle invalidations without making delivery part of run success", async () => {
+    const publish = vi.fn()
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error("notification unavailable"))
+      .mockResolvedValue(undefined)
+    const harness = createHarness({ eventPublisher: { publish } })
+
+    const run = await harness.executor.run({ automationId: harness.automation.id, request: harness.request })
+
+    expect(run.status).toBe("succeeded")
+    expect(publish.mock.calls.map(([item]) => item.status)).toEqual(expect.arrayContaining(["queued", "dispatching", "running", "succeeded"]))
+    expect(publish).toHaveBeenLastCalledWith(expect.objectContaining({
+      workspaceId: harness.actor.workspaceId,
+      userId: harness.actor.userId,
+      automationId: harness.automation.id,
+      runId: run.id,
+      status: "succeeded",
+    }))
+  })
+
+  it("heartbeats an active run until its event stream completes", async () => {
+    vi.useFakeTimers()
+    const release = deferred<void>()
+    const dispatch = vi.fn(async (input: { requestId: string }) => ({
+      ref: { agentTypeId: "default", sessionId: "session-1" },
+      receipt: { accepted: true as const, cursor: 0, disposition: "prompt" as const, clientNonce: input.requestId },
+      events: (async function* () {
+        await release.promise
+        yield event(0, { type: "agent-end", seq: 1, turnId: "turn-1", status: "ok" })
+      })(),
+    }))
+    const dispatcher = {
+      dispatch,
+      send: vi.fn(),
+      interrupt: vi.fn(),
+      stop: vi.fn(),
+    }
+    const harness = createHarness({ resolver: { resolve: vi.fn(async () => dispatcher) } as never })
+
+    const execution = harness.executor.run({ automationId: harness.automation.id, request: harness.request })
+    await vi.waitFor(() => expect(dispatch).toHaveBeenCalledOnce())
+    await vi.advanceTimersByTimeAsync(30_000)
+
+    expect(harness.store.heartbeatCount).toBe(1)
+    release.resolve()
+    await execution
+  })
+
   it("records an executor-owned scheduled occurrence without changing snapshots", async () => {
     const harness = createHarness({ prompt: "scheduled prompt", model: "test:scheduled-model" })
     const run = await harness.executor.run({
@@ -204,6 +266,28 @@ describe("ManualRunExecutor", () => {
     })
   })
 
+  it("returns the durable reconciled run when catch-path finalization loses its lease", async () => {
+    const harness = createHarness({ streamError: new Error("stream crashed") })
+    const updateRunLifecycle = harness.store.updateRunLifecycle.bind(harness.store)
+    vi.spyOn(harness.store, "updateRunLifecycle").mockImplementation(async (runId, patch) => {
+      if (patch.status === "failed") {
+        const current = harness.store.runs.get(runId)!
+        harness.store.runs.set(runId, {
+          ...current,
+          status: "outcome-unknown",
+          completedAt: "2026-07-10T00:05:00.000Z",
+          error: "Automation worker lease expired",
+        })
+        throw runLeaseLost(runId)
+      }
+      return await updateRunLifecycle(runId, patch)
+    })
+
+    const run = await harness.executor.run({ automationId: harness.automation.id, request: harness.request })
+
+    expect(run).toMatchObject({ status: "outcome-unknown", error: "Automation worker lease expired" })
+  })
+
   it("maps aborted terminal events to cancelled runs", async () => {
     const harness = createHarness({
       events: [event(0, { type: "agent-end", seq: 1, turnId: "turn-1", status: "aborted" })],
@@ -272,6 +356,7 @@ describe("ManualRunExecutor", () => {
 
     expect(run).toMatchObject({ status: "failed", startedAt: null, sessionId: null, error: "no dispatcher" })
     expect(harness.store.lifecyclePatches).toEqual([
+      expect.objectContaining({ status: "dispatching" }),
       expect.objectContaining({ status: "failed", sessionId: null }),
     ])
   })
@@ -283,10 +368,17 @@ interface HarnessOptions {
   events?: AgentEvent[]
   streamError?: unknown
   resolver?: WorkspaceAgentDispatcherResolver
+  eventPublisher?: AutomationRunEventPublisher
   request?: FastifyRequest
   clockDates?: string[]
 }
 
+function deferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  const promise = new Promise<T>((promiseResolve) => { resolve = promiseResolve })
+  return { promise, resolve }
+}
+
 function createHarness(options: HarnessOptions = {}) {
   const store = new MemoryAutomationStore()
   const automation = store.seedAutomation({ model: options.model ?? "test:gpt-5.5", prompt: options.prompt ?? "canonical prompt" })
@@ -299,7 +391,7 @@ function createHarness(options: HarnessOptions = {}) {
   const dispatcher = createDispatcher(options.events ?? defaultEvents, options.streamError)
   const resolver = options.resolver ?? { resolve: vi.fn(async () => dispatcher) }
   const clock = clockFrom(options.clockDates)
-  const executor = new ManualRunExecutor({ store, dispatcherResolver: resolver, actorResolver, clock })
+  const executor = new ManualRunExecutor({ store, dispatcherResolver: resolver, actorResolver, eventPublisher: options.eventPublisher, clock })
   return { store, automation, actor, actorResolver, request, dispatcher, resolver, executor }
 }
 
@@ -345,6 +437,7 @@ class MemoryAutomationStore implements AutomationStore {
   readonly prompts = new Map<string, string>()
   readonly runs = new Map<string, AutomationRun>()
   readonly lifecyclePatches: AutomationRunLifecyclePatch[] = []
+  heartbeatCount = 0
   private nextAutomationId = 1
   private nextRunId = 1
 
@@ -434,6 +527,20 @@ class MemoryAutomationStore implements AutomationStore {
     return clone(run)
   }
 
+  async claimRunForDispatch(runId: string): Promise<AutomationRun | null> {
+    const run = this.runs.get(runId)
+    if (!run) throw runNotFound(runId)
+    if (run.status !== "queued") return null
+    return await this.updateRunLifecycle(runId, { status: "dispatching" })
+  }
+
+  async heartbeatRun(runId: string): Promise<boolean> {
+    const run = this.runs.get(runId)
+    if (!run) throw runNotFound(runId)
+    this.heartbeatCount += 1
+    return true
+  }
+
   async updateRunLifecycle(runId: string, patch: AutomationRunLifecyclePatch): Promise<AutomationRun> {
     const run = this.runs.get(runId)
     if (!run) throw runNotFound(runId)
diff --git a/plugins/boring-automation/src/server/__tests__/migrations.test.ts b/plugins/boring-automation/src/server/__tests__/migrations.test.ts
index 70a691716..48f85bf6d 100644
--- a/plugins/boring-automation/src/server/__tests__/migrations.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/migrations.test.ts
@@ -1,5 +1,10 @@
+import { randomUUID } from "node:crypto"
+import postgres from "postgres"
 import { describe, expect, it, vi } from "vitest"
 import { runBoringAutomationMigrations } from "../migrations"
+import { PostgresAutomationStore, reconcileStaleHostedAutomationRuns } from "../postgresStore"
+
+const TEST_DB_URL = process.env.DATABASE_URL ?? "postgres://ubuntu:test@localhost/boring_ui_test"
 
 describe("runBoringAutomationMigrations", () => {
   it("registers hosted automation tables and atomic lease indexes through deployment SQL", async () => {
@@ -14,7 +19,80 @@ describe("runBoringAutomationMigrations", () => {
     expect(statements.some((statement) => statement.includes("DROP COLUMN IF EXISTS prompt"))).toBe(true)
     expect(statements.some((statement) => statement.includes("DROP COLUMN IF EXISTS prompt_file_ready"))).toBe(true)
     expect(statements.some((statement) => statement.includes("boring_automation_automations_active_owner_idx") && statement.includes("WHERE deleted_at IS NULL"))).toBe(true)
+    expect(statements.some((statement) => statement.includes("ADD COLUMN IF NOT EXISTS invocation_id text"))).toBe(true)
+    expect(statements.some((statement) => statement.includes("ALTER COLUMN invocation_id SET NOT NULL"))).toBe(true)
+    expect(statements.some((statement) => statement.includes("status IN ('queued', 'dispatching', 'running'"))).toBe(true)
     expect(statements.some((statement) => statement.includes("boring_automation_runs_active_once_idx"))).toBe(true)
+    expect(statements.some((statement) => statement.includes("boring_automation_runs_invocation_once_idx"))).toBe(true)
     expect(statements.some((statement) => statement.includes("boring_automation_runs_scheduled_once_idx"))).toBe(true)
   })
+
+  it("migrates the hosted schema through a dispatched run", async () => {
+    const sql = postgres(TEST_DB_URL, { max: 1 })
+    const automationId = randomUUID()
+    const actor = {
+      workspaceId: `migration-smoke-workspace-${randomUUID()}`,
+      userId: `migration-smoke-user-${randomUUID()}`,
+    }
+    try {
+      await runBoringAutomationMigrations(sql)
+      const now = new Date().toISOString()
+      await sql`
+        INSERT INTO boring_automation_automations (
+          id, workspace_id, owner_user_id, title, enabled, cron, timezone, model, created_at, updated_at
+        ) VALUES (
+          ${automationId}, ${actor.workspaceId}, ${actor.userId}, 'Migration smoke', true,
+          '0 9 * * *', 'UTC', 'test:model', ${now}, ${now}
+        )
+      `
+      const store = new PostgresAutomationStore(sql, actor)
+      const run = await store.beginRun({
+        automationId,
+        invocationId: `manual:${randomUUID()}`,
+        trigger: "manual",
+        promptSnapshot: "smoke",
+        modelSnapshot: "test:model",
+      })
+
+      expect(run).toMatchObject({ status: "queued", dispatchRequestId: run.id })
+      await expect(store.claimRunForDispatch(run.id)).resolves.toMatchObject({
+        id: run.id,
+        status: "dispatching",
+      })
+
+      const sessionId = randomUUID()
+      const dispatchReceipt = {
+        ref: { agentTypeId: "default", sessionId },
+        accepted: true as const,
+        cursor: 1,
+        clientNonce: run.id,
+        disposition: "prompt" as const,
+      }
+      await expect(store.updateRunLifecycle(run.id, {
+        status: "running",
+        sessionId,
+        dispatchReceipt,
+      })).resolves.toMatchObject({
+        id: run.id,
+        status: "running",
+        sessionId,
+        dispatchReceipt,
+      })
+
+      await sql`UPDATE boring_automation_runs SET updated_at = '2026-07-10T00:00:00.000Z' WHERE id = ${run.id}`
+      const reconciled = await reconcileStaleHostedAutomationRuns(sql, 60_000)
+      expect(reconciled).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          actor,
+          run: expect.objectContaining({ id: run.id, status: "failed", completedAt: expect.any(String) }),
+        }),
+      ]))
+      await expect(store.updateRunLifecycle(run.id, { status: "succeeded" })).rejects.toMatchObject({
+        code: "BORING_AUTOMATION_RUN_LEASE_LOST",
+      })
+    } finally {
+      await sql`DELETE FROM boring_automation_automations WHERE id = ${automationId}`.catch(() => undefined)
+      await sql.end()
+    }
+  })
 })
diff --git a/plugins/boring-automation/src/server/__tests__/nestedToolDispatch.test.ts b/plugins/boring-automation/src/server/__tests__/nestedToolDispatch.test.ts
index 4d9054c61..c1246e7aa 100644
--- a/plugins/boring-automation/src/server/__tests__/nestedToolDispatch.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/nestedToolDispatch.test.ts
@@ -304,6 +304,12 @@ class NestedAutomationStore implements AutomationStore {
     }
     return this.run
   }
+  async claimRunForDispatch(_runId: string) {
+    if (!this.run) throw new Error("run missing")
+    if (this.run.status !== "queued") return null
+    return await this.updateRunLifecycle(this.run.id, { status: "dispatching" })
+  }
+  async heartbeatRun(_runId: string) { return true }
   async updateRunLifecycle(_runId: string, patch: AutomationRunLifecyclePatch) {
     if (!this.run) throw new Error("run missing")
     this.run = { ...this.run, ...patch, updatedAt: patch.completedAt ?? this.run.updatedAt }
diff --git a/plugins/boring-automation/src/server/__tests__/operations.test.ts b/plugins/boring-automation/src/server/__tests__/operations.test.ts
index 17077c882..053d1663e 100644
--- a/plugins/boring-automation/src/server/__tests__/operations.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/operations.test.ts
@@ -61,6 +61,8 @@ function storeMock(overrides: Partial<AutomationStore> = {}) {
     updatePrompt: vi.fn(async () => {}),
     reconcileOrphanedRuns: vi.fn(async () => {}),
     beginRun: vi.fn(async () => run()),
+    claimRunForDispatch: vi.fn(async () => run({ status: "dispatching" })),
+    heartbeatRun: vi.fn(async () => true),
     updateRunLifecycle: vi.fn(async () => run()),
     listRuns: vi.fn(async () => [run()]),
     ...overrides,
diff --git a/plugins/boring-automation/src/server/__tests__/postgresStore.test.ts b/plugins/boring-automation/src/server/__tests__/postgresStore.test.ts
index 5e2ddfdd6..941365f93 100644
--- a/plugins/boring-automation/src/server/__tests__/postgresStore.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/postgresStore.test.ts
@@ -46,6 +46,32 @@ describe("PostgresAutomationStore actor isolation", () => {
     }
   })
 
+  it("pushes the requested run-history limit into Postgres", async () => {
+    const recorded = recordingSql([])
+    const store = new PostgresAutomationStore(recorded.sql, { workspaceId: "workspace-a", userId: "user-a" })
+
+    await store.listRuns("automation-a", 1)
+
+    expect(recorded.queries[0]?.text).toContain("LIMIT ?")
+    expect(recorded.queries[0]?.values).toContain(1)
+  })
+
+  it("claims queued dispatch atomically within the actor scope", async () => {
+    const recorded = recordingSql([])
+    const actor = { workspaceId: "workspace-a", userId: "user-a" }
+    const store = new PostgresAutomationStore(recorded.sql, actor)
+
+    await expect(store.claimRunForDispatch("run-1")).resolves.toBeNull()
+
+    expect(recorded.queries).toHaveLength(1)
+    expect(recorded.queries[0]!.text).toContain("UPDATE boring_automation_runs")
+    expect(recorded.queries[0]!.text).toContain("status = 'queued'")
+    expect(recorded.queries[0]!.text).toContain("RETURNING *")
+    expect(recorded.queries[0]!.values).toEqual(expect.arrayContaining([
+      "run-1", actor.workspaceId, actor.userId,
+    ]))
+  })
+
   it("reads canonical prompts from the workspace without querying PostgreSQL prompt bodies", async () => {
     const row = {
       id: "automation-1",
@@ -162,9 +188,14 @@ describe("PostgresAutomationStore actor isolation", () => {
   it("excludes tombstoned automations from hosted due candidates", async () => {
     const recorded = recordingSql([])
 
-    await expect(listHostedAutomationCandidates(recorded.sql)).resolves.toEqual([])
+    await expect(listHostedAutomationCandidates(recorded.sql, "2026-07-23T09:00:00.000Z")).resolves.toEqual([])
 
     expect(recorded.queries[0]!.text).toContain("FROM boring_automation_automations")
     expect(recorded.queries[0]!.text).toContain("WHERE deleted_at IS NULL")
+    expect(recorded.queries[0]!.text).not.toContain("prompt")
+    expect(recorded.queries[1]!.text).toContain("runs.status IN ('queued', 'dispatching', 'running')")
+    expect(recorded.queries[1]!.text).toContain("runs.scheduled_for = ?")
+    expect(recorded.queries[1]!.text).not.toContain("SELECT *")
+    expect(recorded.queries[1]!.values).toContain("2026-07-23T09:00:00.000Z")
   })
 })
diff --git a/plugins/boring-automation/src/server/__tests__/routes.test.ts b/plugins/boring-automation/src/server/__tests__/routes.test.ts
index 6827811b1..6cf8cad49 100644
--- a/plugins/boring-automation/src/server/__tests__/routes.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/routes.test.ts
@@ -6,6 +6,7 @@ import { describe, expect, it, vi } from "vitest"
 import { BORING_AUTOMATION_ROUTE_PREFIX } from "../../shared"
 import { FileAutomationStore } from "../fileStore"
 import { automationRoutes } from "../routes"
+import { InMemoryAutomationRunEventBus } from "../runEventBus"
 
 function appWithStore(
   store = new FileAutomationStore(`${tmpdir()}/boring-automation-unused`),
@@ -20,6 +21,83 @@ function appWithStore(
 }
 
 describe("automationRoutes", () => {
+  it("streams actor-scoped run invalidations and cleans up on disconnect", async () => {
+    const store = new FileAutomationStore(`${tmpdir()}/boring-automation-events`)
+    const bus = new InMemoryAutomationRunEventBus()
+    const unsubscribed = vi.fn()
+    const originalSubscribe = bus.subscribe.bind(bus)
+    vi.spyOn(bus, "subscribe").mockImplementation(async (...args) => {
+      const unsubscribe = await originalSubscribe(...args)
+      return () => {
+        unsubscribed()
+        unsubscribe()
+      }
+    })
+    const app = Fastify()
+    await automationRoutes(app, {
+      store,
+      actorResolver: () => ({ workspaceId: "workspace-a", userId: "user-a" }),
+      eventBus: bus,
+    })
+    const address = await app.listen({ host: "127.0.0.1", port: 0 })
+    const controller = new AbortController()
+    try {
+      const response = await fetch(`${address}${BORING_AUTOMATION_ROUTE_PREFIX}/events`, { signal: controller.signal })
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toContain("text/event-stream")
+      const reader = response.body!.getReader()
+      const first = new TextDecoder().decode((await reader.read()).value)
+      expect(first).toContain("event: ready")
+
+      await bus.publish({
+        v: 1,
+        eventId: "event-1",
+        workspaceId: "workspace-a",
+        userId: "user-a",
+        automationId: "automation-a",
+        runId: "run-a",
+        status: "succeeded",
+        updatedAt: "2026-07-10T00:00:00.000Z",
+      })
+      const second = new TextDecoder().decode((await reader.read()).value)
+      expect(second).toContain("event: run.changed")
+      expect(second).toContain('"automationId":"automation-a"')
+    } finally {
+      controller.abort()
+      await vi.waitFor(() => expect(unsubscribed).toHaveBeenCalledOnce())
+      await app.close()
+    }
+  })
+
+  it("does not leak a subscription when the client disconnects during actor resolution", async () => {
+    let resolveActor!: (actor: { workspaceId: string; userId: string }) => void
+    let markActorResolutionStarted!: () => void
+    const actorResolutionStarted = new Promise<void>((resolve) => { markActorResolutionStarted = resolve })
+    const actor = new Promise<{ workspaceId: string; userId: string }>((resolve) => { resolveActor = resolve })
+    const unsubscribed = vi.fn()
+    const subscribe = vi.fn(async () => unsubscribed)
+    const app = Fastify()
+    await automationRoutes(app, {
+      store: new FileAutomationStore(`${tmpdir()}/boring-automation-events-delayed`),
+      actorResolver: () => {
+        markActorResolutionStarted()
+        return actor
+      },
+      eventBus: { publish: vi.fn(), subscribe, close: vi.fn() },
+    })
+    const address = await app.listen({ host: "127.0.0.1", port: 0 })
+    const controller = new AbortController()
+    const request = fetch(`${address}${BORING_AUTOMATION_ROUTE_PREFIX}/events`, { signal: controller.signal }).catch(() => undefined)
+    await actorResolutionStarted
+    controller.abort()
+    resolveActor({ workspaceId: "workspace-a", userId: "user-a" })
+    await request
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    if (subscribe.mock.calls.length > 0) expect(unsubscribed).toHaveBeenCalledOnce()
+    await app.close()
+  })
+
   it("creates, reads, patches, and lists automations without workspace request context", async () => {
     const temp = await TempStore.create()
     const app = appWithStore(temp.store)
@@ -107,6 +185,11 @@ describe("automationRoutes", () => {
     const runs = await app.inject({ method: "GET", url: `${BORING_AUTOMATION_ROUTE_PREFIX}/automations/${automation.id}/runs` })
     expect(runs.statusCode).toBe(200)
     expect(runs.json().runs).toEqual([expect.objectContaining({ id: run.id, automationId: automation.id, status: "queued" })])
+    const latestRun = await app.inject({ method: "GET", url: `${BORING_AUTOMATION_ROUTE_PREFIX}/automations/${automation.id}/runs?limit=1` })
+    expect(latestRun.statusCode).toBe(200)
+    expect(latestRun.json().runs).toHaveLength(1)
+    const invalidLimit = await app.inject({ method: "GET", url: `${BORING_AUTOMATION_ROUTE_PREFIX}/automations/${automation.id}/runs?limit=0` })
+    expect(invalidLimit.statusCode).toBe(400)
 
     const createResponse = await app.inject({
       method: "POST",
@@ -169,6 +252,8 @@ describe("automationRoutes", () => {
 
     expect(response.statusCode).toBe(503)
     expect(response.json()).toMatchObject({ code: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE" })
+    const events = await app.inject({ method: "GET", url: `${BORING_AUTOMATION_ROUTE_PREFIX}/events` })
+    expect(events.statusCode).toBe(503)
     await app.close()
     await temp.cleanup()
   })
diff --git a/plugins/boring-automation/src/server/__tests__/runEventBus.test.ts b/plugins/boring-automation/src/server/__tests__/runEventBus.test.ts
new file mode 100644
index 000000000..ee223f3f0
--- /dev/null
+++ b/plugins/boring-automation/src/server/__tests__/runEventBus.test.ts
@@ -0,0 +1,65 @@
+import { randomUUID } from "node:crypto"
+import postgres from "postgres"
+import { describe, expect, it, vi } from "vitest"
+import type { AutomationRunChangedEvent } from "../../shared/types"
+import { InMemoryAutomationRunEventBus, parseAutomationRunChangedEvent, PostgresAutomationRunEventBus } from "../runEventBus"
+
+const TEST_DB_URL = process.env.DATABASE_URL ?? "postgres://ubuntu:test@localhost/boring_ui_test"
+
+function event(overrides: Partial<AutomationRunChangedEvent> = {}): AutomationRunChangedEvent {
+  return {
+    v: 1,
+    eventId: randomUUID(),
+    workspaceId: "workspace-a",
+    userId: "user-a",
+    automationId: "automation-a",
+    runId: "run-a",
+    status: "succeeded",
+    updatedAt: "2026-07-10T00:00:00.000Z",
+    ...overrides,
+  }
+}
+
+describe("automation run event bus", () => {
+  it("isolates in-memory subscribers by workspace and user", async () => {
+    const bus = new InMemoryAutomationRunEventBus()
+    const matching = vi.fn()
+    const otherWorkspace = vi.fn()
+    const otherUser = vi.fn()
+    await bus.subscribe({ workspaceId: "workspace-a", userId: "user-a" }, matching)
+    await bus.subscribe({ workspaceId: "workspace-b", userId: "user-a" }, otherWorkspace)
+    await bus.subscribe({ workspaceId: "workspace-a", userId: "user-b" }, otherUser)
+
+    await bus.publish(event())
+
+    expect(matching).toHaveBeenCalledOnce()
+    expect(otherWorkspace).not.toHaveBeenCalled()
+    expect(otherUser).not.toHaveBeenCalled()
+  })
+
+  it("delivers invalidations across Postgres-backed bus instances", async () => {
+    const publisherSql = postgres(TEST_DB_URL, { max: 1 })
+    const subscriberSql = postgres(TEST_DB_URL, { max: 1 })
+    const publisher = new PostgresAutomationRunEventBus(publisherSql)
+    const subscriber = new PostgresAutomationRunEventBus(subscriberSql)
+    try {
+      let resolveReceived!: (event: AutomationRunChangedEvent) => void
+      const received = new Promise<AutomationRunChangedEvent>((resolve) => { resolveReceived = resolve })
+      const otherActor = vi.fn()
+      await subscriber.subscribe({ workspaceId: "workspace-a", userId: "user-a" }, resolveReceived)
+      await subscriber.subscribe({ workspaceId: "workspace-a", userId: "user-b" }, otherActor)
+      const expected = event()
+      await publisher.publish(expected)
+      await expect(received).resolves.toEqual(expected)
+      expect(otherActor).not.toHaveBeenCalled()
+    } finally {
+      await Promise.all([publisher.close(), subscriber.close()])
+      await Promise.all([publisherSql.end(), subscriberSql.end()])
+    }
+  })
+
+  it("rejects malformed notification payloads", () => {
+    expect(parseAutomationRunChangedEvent("not-json")).toBeNull()
+    expect(parseAutomationRunChangedEvent(JSON.stringify({ ...event(), status: "unknown" }))).toBeNull()
+  })
+})
diff --git a/plugins/boring-automation/src/server/__tests__/serverPlugin.test.ts b/plugins/boring-automation/src/server/__tests__/serverPlugin.test.ts
index ffb32fdc3..5e1fa2280 100644
--- a/plugins/boring-automation/src/server/__tests__/serverPlugin.test.ts
+++ b/plugins/boring-automation/src/server/__tests__/serverPlugin.test.ts
@@ -102,6 +102,126 @@ describe("boring automation server plugin", () => {
     expect(sql).not.toHaveBeenCalled()
   })
 
+  it("starts hosted due evaluation internally when Fastify becomes ready", async () => {
+    const runDue = vi.fn(async () => ({ now: "2026-07-23T09:00:00.000Z", outcomes: [] }))
+    const plugin = createBoringAutomationServerPlugin({
+      store: {} as never,
+      hostedDueRunService: { runDue },
+    })
+    const app = Fastify()
+    await app.register(plugin.routes!)
+    await app.ready()
+
+    expect(runDue).toHaveBeenCalledOnce()
+    expect(runDue).toHaveBeenCalledWith()
+    await app.close()
+  })
+
+  it("shares one due evaluation between the internal tick and hosted endpoint", async () => {
+    let resolveRun!: (value: { now: string; outcomes: [] }) => void
+    const activeRun = new Promise<{ now: string; outcomes: [] }>((resolve) => { resolveRun = resolve })
+    const runDue = vi.fn(async () => await activeRun)
+    const plugin = createBoringAutomationServerPlugin({
+      store: {} as never,
+      hostedDueRunService: { runDue },
+      hostedTriggerToken: "trigger-secret",
+    })
+    const app = Fastify()
+    await app.register(plugin.routes!)
+    await app.ready()
+
+    const endpointResponse = app.inject({
+      method: "POST",
+      url: `${BORING_AUTOMATION_ROUTE_PREFIX}/due/hosted`,
+      headers: { authorization: "Bearer trigger-secret" },
+    })
+    await new Promise<void>((resolve) => setImmediate(resolve))
+    expect(runDue).toHaveBeenCalledOnce()
+    expect(runDue).toHaveBeenCalledWith()
+
+    resolveRun({ now: "2026-07-23T09:00:00.000Z", outcomes: [] })
+    expect((await endpointResponse).statusCode).toBe(200)
+    await app.close()
+  })
+
+  it("stops timer admission without delaying close for an active durable run", async () => {
+    let resolveRun!: (value: { now: string; outcomes: [] }) => void
+    const activeRun = new Promise<{ now: string; outcomes: [] }>((resolve) => { resolveRun = resolve })
+    const plugin = createBoringAutomationServerPlugin({
+      store: {} as never,
+      hostedDueRunService: { runDue: async () => await activeRun },
+    })
+    const app = Fastify()
+    await app.register(plugin.routes!)
+    await app.ready()
+    await new Promise<void>((resolve) => setImmediate(resolve))
+
+    await expect(app.close()).resolves.toBeUndefined()
+    resolveRun({ now: "2026-07-23T09:00:00.000Z", outcomes: [] })
+    await new Promise<void>((resolve) => setImmediate(resolve))
+  })
+
+  it("leaves a caller-owned event bus open and closes a plugin-owned bus", async () => {
+    const callerClose = vi.fn(async () => {})
+    const callerPlugin = createBoringAutomationServerPlugin({
+      store: {} as never,
+      eventBus: { publish: vi.fn(), subscribe: vi.fn(), close: callerClose } as never,
+    })
+    const callerApp = Fastify()
+    await callerApp.register(callerPlugin.routes!)
+    await callerApp.close()
+    expect(callerClose).not.toHaveBeenCalled()
+
+    const pluginClose = vi.fn(async () => {})
+    const ownedPlugin = createBoringAutomationServerPlugin({
+      store: {} as never,
+      eventBus: { publish: vi.fn(), subscribe: vi.fn(), close: pluginClose } as never,
+      eventBusOwner: "plugin",
+    })
+    const ownedApp = Fastify()
+    await ownedApp.register(ownedPlugin.routes!)
+    await ownedApp.close()
+    expect(pluginClose).toHaveBeenCalledOnce()
+  })
+
+  it("allows hosted composition to opt out when an external scheduler owns wake-ups", async () => {
+    const runDue = vi.fn(async () => ({ now: "2026-07-23T09:00:00.000Z", outcomes: [] }))
+    const plugin = createBoringAutomationServerPlugin({
+      store: {} as never,
+      hostedDueRunService: { runDue },
+      hostedSchedulerEnabled: false,
+    })
+    const app = Fastify()
+    await app.register(plugin.routes!)
+    await app.ready()
+
+    expect(runDue).not.toHaveBeenCalled()
+    await app.close()
+  })
+
+  it("honors the hosted scheduler environment opt-out in default composition", async () => {
+    vi.stubEnv("BORING_AUTOMATION_INTERNAL_SCHEDULER", "false")
+    const sql = vi.fn(async () => [])
+    const plugin = defaultBoringAutomationServerPlugin({}, {
+      workspaceRoot: "/hosted/workspace",
+      trusted: {
+        sql: sql as never,
+        workspaceAgentDispatcherResolver: { resolve: vi.fn() } as never,
+        actorResolver: vi.fn(),
+        actorVerifier: vi.fn(() => true),
+      },
+    })
+    const app = Fastify()
+    try {
+      await app.register(plugin.routes!)
+      await app.ready()
+      expect(sql).not.toHaveBeenCalled()
+    } finally {
+      await app.close()
+      vi.unstubAllEnvs()
+    }
+  })
+
   it("requires workspaceRoot when no store is provided", () => {
     expect(() => createBoringAutomationServerPlugin()).toThrow(/requires workspaceRoot/)
   })
diff --git a/plugins/boring-automation/src/server/automationTool.ts b/plugins/boring-automation/src/server/automationTool.ts
index 6dbffbdb8..830ff186a 100644
--- a/plugins/boring-automation/src/server/automationTool.ts
+++ b/plugins/boring-automation/src/server/automationTool.ts
@@ -204,6 +204,7 @@ function publicErrorMessage(code: BoringAutomationErrorCode): string {
     case BORING_AUTOMATION_ERROR_CODES.RUN_NOT_FOUND: return "Automation run not found in the active workspace."
     case BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE: return "This automation already has an active run."
     case BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED: return "This scheduled automation occurrence was already recorded."
+    case BORING_AUTOMATION_ERROR_CODES.RUN_LEASE_LOST: return "This automation run was recovered by another worker."
     case BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE: return "Automation execution is unavailable."
     case BORING_AUTOMATION_ERROR_CODES.TOOL_CONTEXT_UNAVAILABLE: return "Automation tool context is unavailable."
     case BORING_AUTOMATION_ERROR_CODES.TOOL_ABORTED: return "Automation tool call was aborted."
diff --git a/plugins/boring-automation/src/server/fileStore.ts b/plugins/boring-automation/src/server/fileStore.ts
index d41ce036f..ea6490112 100644
--- a/plugins/boring-automation/src/server/fileStore.ts
+++ b/plugins/boring-automation/src/server/fileStore.ts
@@ -11,7 +11,7 @@ import type {
 } from "../shared/types"
 import { automationPromptPath } from "../shared/prompt"
 import type { AutomationStore } from "./store"
-import { automationNotFound, runAlreadyActive, runAlreadyRecorded, runNotFound } from "./store"
+import { automationNotFound, runAlreadyActive, runAlreadyRecorded, runLeaseLost, runNotFound } from "./store"
 
 type StoredAutomationState = {
   automations: Record<string, Automation>
@@ -205,11 +205,37 @@ export class FileAutomationStore implements AutomationStore {
     return clone(requireValue(run))
   }
 
+  async claimRunForDispatch(runId: string): Promise<AutomationRun | null> {
+    let claimed: AutomationRun | undefined
+    await this.mutate((state) => {
+      const run = state.runs[runId]
+      if (!run) throw runNotFound(runId)
+      if (run.status !== "queued") return
+      claimed = applyRunPatch(run, { status: "dispatching" }, this.nowIso())
+      state.runs[runId] = claimed
+    })
+    return claimed ? clone(claimed) : null
+  }
+
+  async heartbeatRun(runId: string): Promise<boolean> {
+    let renewed = false
+    await this.mutate((state) => {
+      const run = state.runs[runId]
+      if (!run) throw runNotFound(runId)
+      if (run.status === "queued" || run.status === "dispatching" || run.status === "running") {
+        state.runs[runId] = { ...run, updatedAt: this.nowIso() }
+        renewed = true
+      }
+    })
+    return renewed
+  }
+
   async updateRunLifecycle(runId: string, patch: AutomationRunLifecyclePatch): Promise<AutomationRun> {
     let updated: AutomationRun | undefined
     await this.mutate((state) => {
       const run = state.runs[runId]
       if (!run) throw runNotFound(runId)
+      if (run.status !== "queued" && run.status !== "dispatching" && run.status !== "running") throw runLeaseLost(runId)
       updated = applyRunPatch(run, patch, this.nowIso())
       state.runs[runId] = updated
     })
@@ -217,14 +243,14 @@ export class FileAutomationStore implements AutomationStore {
     return clone(requireValue(updated))
   }
 
-  async listRuns(automationId: string): Promise<AutomationRun[]> {
+  async listRuns(automationId: string, limit?: number): Promise<AutomationRun[]> {
     const automation = await this.getAutomation(automationId)
     if (!automation) throw automationNotFound(automationId)
     const state = await this.load()
-    return Object.values(state.runs)
+    const runs = Object.values(state.runs)
       .filter((run) => run.automationId === automationId)
       .sort((a, b) => runSortTimestamp(b).localeCompare(runSortTimestamp(a)))
-      .map(clone)
+    return runs.slice(0, limit ?? runs.length).map(clone)
   }
 
   private statePath(): string {
diff --git a/plugins/boring-automation/src/server/hostedDueCoordinator.ts b/plugins/boring-automation/src/server/hostedDueCoordinator.ts
new file mode 100644
index 000000000..3fe57641d
--- /dev/null
+++ b/plugins/boring-automation/src/server/hostedDueCoordinator.ts
@@ -0,0 +1,28 @@
+import type { FastifyRequest } from "fastify"
+import type { HostedDueRunResult } from "./hostedDueRunService"
+
+export interface HostedDueRunner {
+  runDue(request?: FastifyRequest): Promise<HostedDueRunResult>
+}
+
+/** Shares one in-process due evaluation across timer and HTTP wake-ups. */
+export class HostedDueCoordinator implements HostedDueRunner {
+  private active: Promise<HostedDueRunResult> | undefined
+
+  constructor(private readonly runner: HostedDueRunner) {}
+
+  runDue(request?: FastifyRequest): Promise<HostedDueRunResult> {
+    if (this.active) return this.active
+    const active = request ? this.runner.runDue(request) : this.runner.runDue()
+    this.active = active
+    void active.then(
+      () => this.clear(active),
+      () => this.clear(active),
+    )
+    return active
+  }
+
+  private clear(completed: Promise<HostedDueRunResult>): void {
+    if (this.active === completed) this.active = undefined
+  }
+}
diff --git a/plugins/boring-automation/src/server/hostedDueRunService.ts b/plugins/boring-automation/src/server/hostedDueRunService.ts
index 8e5dc3514..05a3b69d0 100644
--- a/plugins/boring-automation/src/server/hostedDueRunService.ts
+++ b/plugins/boring-automation/src/server/hostedDueRunService.ts
@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto"
 import type postgres from "postgres"
 import type { FastifyRequest } from "fastify"
 import { BORING_AUTOMATION_ERROR_CODES } from "../shared/error-codes"
@@ -5,13 +6,18 @@ import { evaluateAutomationSchedule } from "../shared/schedule"
 import type { AutomationRun } from "../shared/types"
 import { type DueRunOutcome, type DueRunSummary } from "./dueRunService"
 import { ManualRunExecutor } from "./manualRunExecutor"
-import { listHostedAutomationCandidates, PostgresAutomationStore, type HostedAutomationActor } from "./postgresStore"
+import { listHostedAutomationCandidates, PostgresAutomationStore, reconcileStaleHostedAutomationRuns, type HostedAutomationActor } from "./postgresStore"
+import type { AutomationRunEventPublisher } from "./runEventBus"
+import { AutomationStoreError } from "./store"
 import type { WorkspaceAgentDispatcherResolver } from "@hachej/boring-agent/server"
 
+const HOSTED_RUN_STALE_AFTER_MS = 5 * 60_000
+
 export interface HostedDueRunServiceOptions {
   sql: postgres.Sql
   dispatcherResolver: WorkspaceAgentDispatcherResolver
   verifyActor: (actor: HostedAutomationActor) => Promise<boolean> | boolean
+  eventPublisher?: AutomationRunEventPublisher
   clock?: () => Date
 }
 
@@ -28,9 +34,26 @@ export class HostedDueRunService {
     this.clock = options.clock ?? (() => new Date())
   }
 
-  async runDue(request: FastifyRequest): Promise<HostedDueRunResult> {
+  async runDue(request?: FastifyRequest): Promise<HostedDueRunResult> {
     const now = this.clock()
-    const candidates = await listHostedAutomationCandidates(this.options.sql)
+    const reconciled = await reconcileStaleHostedAutomationRuns(this.options.sql, HOSTED_RUN_STALE_AFTER_MS)
+    for (const item of reconciled) {
+      try {
+        await this.options.eventPublisher?.publish({
+          v: 1,
+          eventId: randomUUID(),
+          workspaceId: item.actor.workspaceId,
+          userId: item.actor.userId,
+          automationId: item.run.automationId,
+          runId: item.run.id,
+          status: item.run.status,
+          updatedAt: item.run.updatedAt,
+        })
+      } catch {
+        // Reconciliation is durable; UI invalidation remains best effort.
+      }
+    }
+    const candidates = await listHostedAutomationCandidates(this.options.sql, floorToMinute(now).toISOString())
     const outcomes: DueRunOutcome[] = []
 
     for (const candidate of candidates) {
@@ -70,10 +93,11 @@ export class HostedDueRunService {
           store,
           dispatcherResolver: this.options.dispatcherResolver,
           actorResolver: () => candidate.actor,
+          eventPublisher: this.options.eventPublisher,
         })
         const run = await executor.run({
           automationId: candidate.automation.id,
-          request,
+          ...(request ? { request } : {}),
           trigger: "scheduled",
           scheduledFor: decision.scheduledFor,
           actor: candidate.actor,
@@ -85,6 +109,19 @@ export class HostedDueRunService {
           run: toSummary(run),
         })
       } catch (error) {
+        if (error instanceof AutomationStoreError && (
+          error.code === BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE
+          || error.code === BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED
+        )) {
+          outcomes.push({
+            kind: "skipped",
+            automationId: candidate.automation.id,
+            scheduledFor: decision.scheduledFor,
+            reason: error.code === BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE ? "active-run" : "duplicate-scheduled-run",
+            message: error.message,
+          })
+          continue
+        }
         outcomes.push({
           kind: "failed",
           automationId: candidate.automation.id,
@@ -100,6 +137,12 @@ export class HostedDueRunService {
   }
 }
 
+function floorToMinute(value: Date): Date {
+  const minute = new Date(value)
+  minute.setUTCSeconds(0, 0)
+  return minute
+}
+
 function toSummary(run: AutomationRun): DueRunSummary {
   return {
     id: run.id,
diff --git a/plugins/boring-automation/src/server/hostedScheduler.ts b/plugins/boring-automation/src/server/hostedScheduler.ts
new file mode 100644
index 000000000..aea640474
--- /dev/null
+++ b/plugins/boring-automation/src/server/hostedScheduler.ts
@@ -0,0 +1,102 @@
+import { Cron } from "croner"
+import type { FastifyBaseLogger } from "fastify"
+import type { HostedDueRunResult } from "./hostedDueRunService"
+
+const HOSTED_AUTOMATION_TICK_PATTERN = "* * * * *"
+
+type SchedulerLogger = Pick<FastifyBaseLogger, "debug" | "info" | "warn" | "error">
+type RunDue = () => Promise<HostedDueRunResult>
+type ScheduledTick = () => Promise<void>
+type CronJob = Pick<Cron, "stop">
+type ScheduleCron = (tick: ScheduledTick) => CronJob
+
+export interface HostedAutomationSchedulerOptions {
+  runDue: RunDue
+  logger: SchedulerLogger
+  scheduleCron?: ScheduleCron
+}
+
+/** Process-local wake-up for hosted due evaluation. Database constraints remain the cross-process execution guard. */
+export class HostedAutomationScheduler {
+  private job: CronJob | undefined
+  private activeTick: Promise<void> | undefined
+  private stopped = true
+
+  constructor(private readonly options: HostedAutomationSchedulerOptions) {}
+
+  start(): void {
+    if (this.job) return
+    this.stopped = false
+    const scheduleCron = this.options.scheduleCron ?? defaultScheduleCron
+    this.job = scheduleCron(async () => await this.tick())
+    void this.tick()
+  }
+
+  beginShutdown(): void {
+    this.stopped = true
+    this.job?.stop()
+    this.job = undefined
+  }
+
+  private tick(): Promise<void> {
+    if (this.stopped || this.activeTick) return Promise.resolve()
+    const active = this.executeTick()
+    this.activeTick = active
+    void active.then(
+      () => this.clearActiveTick(active),
+      () => this.clearActiveTick(active),
+    )
+    return active
+  }
+
+  private async executeTick(): Promise<void> {
+    try {
+      const result = await this.options.runDue()
+      const summary = summarize(result)
+      if (summary.failed > 0) {
+        this.options.logger.warn({ automationScheduler: summary }, "hosted automation scheduler tick completed with failures")
+      } else if (summary.started > 0) {
+        this.options.logger.info({ automationScheduler: summary }, "hosted automation scheduler started due runs")
+      } else {
+        this.options.logger.debug({ automationScheduler: summary }, "hosted automation scheduler tick completed")
+      }
+    } catch (error) {
+      this.options.logger.error({
+        automationScheduler: {
+          event: "tick-failed",
+          errorName: error instanceof Error ? error.name : "UnknownError",
+        },
+      }, "hosted automation scheduler tick failed")
+    }
+  }
+
+  private clearActiveTick(completed: Promise<void>): void {
+    if (this.activeTick === completed) this.activeTick = undefined
+  }
+}
+
+function defaultScheduleCron(tick: ScheduledTick): CronJob {
+  return new Cron(HOSTED_AUTOMATION_TICK_PATTERN, {
+    mode: "5-part",
+    protect: true,
+    unref: true,
+  }, tick)
+}
+
+function summarize(result: HostedDueRunResult) {
+  let started = 0
+  let skipped = 0
+  let failed = 0
+  for (const outcome of result.outcomes) {
+    if (outcome.kind === "started") started += 1
+    else if (outcome.kind === "skipped") skipped += 1
+    else failed += 1
+  }
+  return {
+    event: "tick-completed",
+    evaluatedAt: result.now,
+    started,
+    skipped,
+    failed,
+  }
+}
diff --git a/plugins/boring-automation/src/server/index.ts b/plugins/boring-automation/src/server/index.ts
index 284ceee65..98dfc77be 100644
--- a/plugins/boring-automation/src/server/index.ts
+++ b/plugins/boring-automation/src/server/index.ts
@@ -9,11 +9,14 @@ import {
 } from "../shared"
 import { DueRunService } from "./dueRunService"
 import { FileAutomationStore } from "./fileStore"
+import { HostedDueCoordinator } from "./hostedDueCoordinator"
 import { HostedDueRunService } from "./hostedDueRunService"
+import { HostedAutomationScheduler } from "./hostedScheduler"
 import { PostgresAutomationStore } from "./postgresStore"
 import { createBoringAutomationTool } from "./automationTool"
 import { ManualRunExecutor, type VerifiedAutomationActor } from "./manualRunExecutor"
 import { resolveAutomationOperationsForActor, type AutomationStoreMode } from "./operations"
+import { InMemoryAutomationRunEventBus, PostgresAutomationRunEventBus, type AutomationRunEventBus } from "./runEventBus"
 import { automationRoutes } from "./routes"
 import type { AutomationStore } from "./store"
 
@@ -31,21 +34,34 @@ export interface BoringAutomationServerPluginOptions {
   actorVerifier?: (actor: VerifiedAutomationActor) => Promise<boolean> | boolean
   hostedTriggerToken?: string
   hostedDueRunService?: Pick<HostedDueRunService, "runDue">
+  eventBus?: AutomationRunEventBus
+  /** Injected buses default to caller-owned; plugin-created buses close with the plugin. */
+  eventBusOwner?: "plugin" | "caller"
+  /** Defaults to true when hosted due execution is composed. Disable when an external scheduler owns wake-ups. */
+  hostedSchedulerEnabled?: boolean
 }
 
 export function createBoringAutomationServerPlugin(options: BoringAutomationServerPluginOptions = {}): WorkspaceServerPlugin {
   const store = options.store ?? createDefaultStore(options.workspaceRoot)
+  const eventBus = options.eventBus ?? new InMemoryAutomationRunEventBus()
+  const eventBusOwner = options.eventBusOwner ?? (options.eventBus ? "caller" : "plugin")
   const manualRunExecutor = options.dispatcherResolver && options.actorResolver
     ? new ManualRunExecutor({
         store,
         storeForRequest: options.storeForRequest,
         dispatcherResolver: options.dispatcherResolver,
         actorResolver: options.actorResolver,
+        eventPublisher: eventBus,
       })
     : undefined
   const dueRunService = manualRunExecutor && !options.storeForRequest
     ? new DueRunService({ store, executor: manualRunExecutor })
     : undefined
+  const hostedDueCoordinator = options.hostedDueRunService
+    ? new HostedDueCoordinator(options.hostedDueRunService)
+    : undefined
+  const hostedSchedulerEnabled = Boolean(hostedDueCoordinator) && options.hostedSchedulerEnabled !== false
+  let scheduler: HostedAutomationScheduler | undefined
   const agentTools = options.agentToolEnabled === false ? [] : [createBoringAutomationTool({
     resolveOperationsForActor: async (actorContext) => resolveAutomationOperationsForActor({
       mode: options.storeMode ?? "local",
@@ -55,28 +71,49 @@ export function createBoringAutomationServerPlugin(options: BoringAutomationServ
             store: actorStore,
             dispatcherResolver: options.dispatcherResolver!,
             actorResolver: () => actor,
+            eventPublisher: eventBus,
           })
         : undefined,
     }, actorContext),
   })]
+  const routes = async (app: Parameters<NonNullable<WorkspaceServerPlugin["routes"]>>[0]) => {
+    await automationRoutes(app, {
+      store,
+      storeForRequest: options.storeForRequest ? async (request) => {
+        const actor = options.actorResolver ? await options.actorResolver(request) : undefined
+        if (!actor) throw new Error("automation actor resolver is unavailable")
+        return await options.storeForRequest!(request, actor)
+      } : undefined,
+      manualRunExecutor,
+      dueRunService,
+      hostedDueRunService: hostedDueCoordinator,
+      hostedTriggerToken: options.hostedTriggerToken,
+      actorResolver: options.actorResolver,
+      eventBus,
+    })
+    app.addHook("preClose", async () => {
+      // Durable leases and stale-run reconciliation own interrupted execution.
+      // Shutdown only fences future timer ticks; it never delays AgentHost close.
+      scheduler?.beginShutdown()
+    })
+    app.addHook("onClose", async () => {
+      // A final invalidation may race shutdown; durable run state remains authoritative.
+      if (eventBusOwner === "plugin") await eventBus.close()
+    })
+
+    if (hostedDueCoordinator && hostedSchedulerEnabled) {
+      scheduler = new HostedAutomationScheduler({
+        runDue: async () => await hostedDueCoordinator.runDue(),
+        logger: app.log,
+      })
+      app.addHook("onReady", async () => scheduler?.start())
+    }
+  }
   return defineServerPlugin({
     id: BORING_AUTOMATION_PLUGIN_ID,
     label: BORING_AUTOMATION_PLUGIN_LABEL,
     agentTools,
-    routes: async (app) => {
-      await automationRoutes(app, {
-        store,
-        storeForRequest: options.storeForRequest ? async (request) => {
-          const actor = options.actorResolver ? await options.actorResolver(request) : undefined
-          if (!actor) throw new Error("automation actor resolver is unavailable")
-          return await options.storeForRequest!(request, actor)
-        } : undefined,
-        manualRunExecutor,
-        dueRunService,
-        hostedDueRunService: options.hostedDueRunService,
-        hostedTriggerToken: options.hostedTriggerToken,
-      })
-    },
+    routes,
   })
 }
 
@@ -104,11 +141,16 @@ export default function defaultBoringAutomationServerPlugin(
   if (!options?.store && trusted?.sql && trusted.workspaceAgentDispatcherResolver && trusted.actorResolver) {
     const sql = trusted.sql as postgres.Sql
     const dispatcherResolver = options?.dispatcherResolver ?? trusted.workspaceAgentDispatcherResolver
+    const eventBus = options?.eventBus ?? new PostgresAutomationRunEventBus(sql)
+    const eventBusOwner = options?.eventBusOwner ?? (options?.eventBus ? "caller" : "plugin")
     const fallbackStore = new PostgresAutomationStore(sql, { workspaceId: "unbound", userId: "unbound" })
     return createBoringAutomationServerPlugin({
       ...options,
+      hostedSchedulerEnabled: options?.hostedSchedulerEnabled ?? process.env.BORING_AUTOMATION_INTERNAL_SCHEDULER !== "false",
       store: fallbackStore,
       storeMode: "hosted",
+      eventBus,
+      eventBusOwner,
       storeForRequest: async (request, actor) => await createHostedStore(sql, actor, dispatcherResolver, request),
       storeForActor: async (actor) => await createHostedStore(sql, actor, dispatcherResolver),
       dispatcherResolver,
@@ -119,6 +161,7 @@ export default function defaultBoringAutomationServerPlugin(
         sql,
         dispatcherResolver,
         verifyActor: options?.actorVerifier ?? trusted.actorVerifier!,
+        eventPublisher: eventBus,
       }),
     })
   }
@@ -139,5 +182,6 @@ export * from "./migrations"
 export * from "./operations"
 export * from "./postgresStore"
 export * from "./routes"
+export * from "./runEventBus"
 export * from "./store"
 export * from "../shared"
diff --git a/plugins/boring-automation/src/server/manualRunExecutor.ts b/plugins/boring-automation/src/server/manualRunExecutor.ts
index ecff313dc..019aab95d 100644
--- a/plugins/boring-automation/src/server/manualRunExecutor.ts
+++ b/plugins/boring-automation/src/server/manualRunExecutor.ts
@@ -5,6 +5,7 @@ import type { AgentEvent } from "@hachej/boring-agent/shared"
 import type { WorkspaceAgentDispatcherResolver } from "@hachej/boring-agent/server"
 import { BORING_AUTOMATION_ERROR_CODES } from "../shared/error-codes"
 import type { AutomationRun } from "../shared/types"
+import type { AutomationRunEventPublisher } from "./runEventBus"
 import type { AutomationStore } from "./store"
 import { AutomationStoreError } from "./store"
 
@@ -18,6 +19,7 @@ export interface ManualRunExecutorOptions {
   storeForRequest?: (request: FastifyRequest, actor: VerifiedAutomationActor) => Promise<AutomationStore> | AutomationStore
   dispatcherResolver: WorkspaceAgentDispatcherResolver
   actorResolver: (request: FastifyRequest) => Promise<VerifiedAutomationActor> | VerifiedAutomationActor
+  eventPublisher?: AutomationRunEventPublisher
   clock?: () => Date
 }
 
@@ -32,6 +34,8 @@ export interface ManualRunInput {
   invocationId?: string
 }
 
+const RUN_HEARTBEAT_INTERVAL_MS = 30_000
+
 interface UsageTotals {
   inputTokens: number | null
   outputTokens: number | null
@@ -82,16 +86,21 @@ export class ManualRunExecutor {
       modelSnapshot,
       createdAt,
     })
+    await this.publishRunChange(actor, run)
     // beginRun is the durable invocation-to-run receipt. A retry of a terminal
     // invocation returns that receipt verbatim and must never enter dispatch
     // again, especially after restart reconciliation made the outcome unknown.
     if (isTerminalRunStatus(run.status)) return run
 
     const usage: UsageAccumulator = { input: null, output: null }
-    let current = run
     let sessionId: string | null = null
     let terminalStatus: "succeeded" | "failed" | "cancelled" | null = null
     let terminalError: string | null = null
+    const claimed = await store.claimRunForDispatch(run.id)
+    if (!claimed) return await this.readDurableRun(store, automation.id, run.id, run)
+    let current = claimed
+    const stopHeartbeat = startRunHeartbeat(store, run.id)
+    await this.publishRunChange(actor, current)
     let startedAt: string | null = null
 
     try {
@@ -100,16 +109,14 @@ export class ManualRunExecutor {
         input.request ? { request: input.request } : undefined,
       )
       startedAt = this.nowIso()
-      current = await store.updateRunLifecycle(run.id, {
-        status: "dispatching",
-        startedAt,
-        sessionId: null,
-      })
+      current = await store.updateRunLifecycle(run.id, { status: "dispatching", startedAt, sessionId: null })
+      await this.publishRunChange(actor, current)
       if (!dispatcher.dispatch) {
         throw new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE, "automation dispatcher does not support addressed Gateway dispatch")
       }
       const dispatched = await dispatcher.dispatch({
         requestId: run.id,
+        title: automationSessionTitle(automation.title, promptSnapshot),
         content: promptSnapshot,
         model,
         ...(automation.thinkingLevel ? { thinkingLevel: automation.thinkingLevel } : {}),
@@ -125,12 +132,14 @@ export class ManualRunExecutor {
           ...dispatched.receipt,
         },
       })
+      await this.publishRunChange(actor, current)
 
       for await (const event of dispatched.events) {
         const eventSessionId = sessionIdFromEvent(event)
         if (!sessionId && eventSessionId) {
           sessionId = eventSessionId
           current = await store.updateRunLifecycle(run.id, { sessionId })
+          await this.publishRunChange(actor, current)
         }
         aggregateUsage(usage, event)
         const outcome = terminalOutcomeFromEvent(event)
@@ -141,7 +150,8 @@ export class ManualRunExecutor {
       }
 
       const completedAt = this.nowIso()
-      return await this.finalizeRun(store, run.id, {
+      await stopHeartbeat()
+      const finalized = await this.finalizeRun(store, run.id, {
         current,
         sessionId,
         startedAt,
@@ -150,19 +160,52 @@ export class ManualRunExecutor {
         error: terminalStatus === "failed" ? (terminalError ?? "Automation run failed") : null,
         usage,
       })
+      await this.publishRunChange(actor, finalized)
+      return finalized
     } catch (error) {
       const completedAt = this.nowIso()
+      await stopHeartbeat()
+      if (isRunLeaseLost(error)) return await this.readDurableRun(store, automation.id, run.id, current)
       const cancelled = isCancellationError(error)
       const status = terminalStatus ?? (cancelled ? "cancelled" : "failed")
-      return await this.finalizeRun(store, run.id, {
-        current,
-        sessionId,
-        startedAt,
-        completedAt,
-        status,
-        error: status === "failed" ? (terminalError ?? safeErrorMessage(error)) : null,
-        usage,
+      let finalized: AutomationRun
+      try {
+        finalized = await this.finalizeRun(store, run.id, {
+          current,
+          sessionId,
+          startedAt,
+          completedAt,
+          status,
+          error: status === "failed" ? (terminalError ?? safeErrorMessage(error)) : null,
+          usage,
+        })
+      } catch (finalizeError) {
+        if (isRunLeaseLost(finalizeError)) return await this.readDurableRun(store, automation.id, run.id, current)
+        throw finalizeError
+      }
+      await this.publishRunChange(actor, finalized)
+      return finalized
+    }
+  }
+
+  private async readDurableRun(store: AutomationStore, automationId: string, runId: string, fallback: AutomationRun): Promise<AutomationRun> {
+    return (await store.listRuns(automationId)).find((candidate) => candidate.id === runId) ?? fallback
+  }
+
+  private async publishRunChange(actor: VerifiedAutomationActor, run: AutomationRun): Promise<void> {
+    try {
+      await this.options.eventPublisher?.publish({
+        v: 1,
+        eventId: randomUUID(),
+        workspaceId: actor.workspaceId,
+        userId: actor.userId,
+        automationId: run.automationId,
+        runId: run.id,
+        status: run.status,
+        updatedAt: run.updatedAt,
       })
+    } catch {
+      // Notifications are best-effort invalidations; durable run state remains authoritative.
     }
   }
 
@@ -190,6 +233,35 @@ export class ManualRunExecutor {
   }
 }
 
+function startRunHeartbeat(store: AutomationStore, runId: string): () => Promise<void> {
+  let stopped = false
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let inFlight: Promise<void> = Promise.resolve()
+  const schedule = () => {
+    if (stopped) return
+    timer = setTimeout(() => {
+      inFlight = store.heartbeatRun(runId)
+        .then((renewed) => {
+          if (renewed) schedule()
+          else stopped = true
+        })
+        .catch(() => schedule())
+    }, RUN_HEARTBEAT_INTERVAL_MS)
+    timer.unref?.()
+  }
+  schedule()
+  return async () => {
+    stopped = true
+    if (timer !== undefined) clearTimeout(timer)
+    await inFlight
+  }
+}
+
+export function automationSessionTitle(automationTitle: string, prompt: string): string {
+  const sessionName = prompt.trim().split(/\r?\n/, 1)[0]?.trim() || "Run"
+  return `Automation ${automationTitle.trim()}: ${sessionName}`.slice(0, 80)
+}
+
 export function parseAutomationModel(value: string): { provider: string; id: string } {
   const index = value.indexOf(":")
   if (index <= 0 || index === value.length - 1) {
@@ -277,6 +349,10 @@ function isTerminalRunStatus(status: AutomationRun["status"]): boolean {
     || status === "outcome-unknown"
 }
 
+function isRunLeaseLost(error: unknown): boolean {
+  return error instanceof AutomationStoreError && error.code === BORING_AUTOMATION_ERROR_CODES.RUN_LEASE_LOST
+}
+
 function isCancellationError(error: unknown): boolean {
   if (!error || typeof error !== "object") return false
   const record = error as { name?: unknown; code?: unknown }
diff --git a/plugins/boring-automation/src/server/postgresStore.ts b/plugins/boring-automation/src/server/postgresStore.ts
index 32dcff6b5..813b03698 100644
--- a/plugins/boring-automation/src/server/postgresStore.ts
+++ b/plugins/boring-automation/src/server/postgresStore.ts
@@ -4,17 +4,24 @@ import type { Workspace } from "@hachej/boring-agent/shared"
 import { BORING_AUTOMATION_ERROR_CODES } from "../shared/error-codes"
 import { AUTOMATION_PROMPT_DIRECTORY, automationPromptPath } from "../shared/prompt"
 import type { Automation, AutomationCreate, AutomationPatch, AutomationRun, AutomationRunBegin, AutomationRunLifecyclePatch } from "../shared/types"
-import { AutomationStoreError, automationNotFound, runAlreadyActive, runAlreadyRecorded, runNotFound, type AutomationStore } from "./store"
+import { AutomationStoreError, automationNotFound, runAlreadyActive, runAlreadyRecorded, runLeaseLost, runNotFound, type AutomationStore } from "./store"
 
 export interface HostedAutomationActor {
   workspaceId: string
   userId: string
 }
 
+export type HostedAutomationRunEvidence = Pick<AutomationRun, "automationId" | "status" | "trigger" | "scheduledFor">
+
 export interface HostedAutomationCandidate {
   automation: Automation
   actor: HostedAutomationActor
-  runs: AutomationRun[]
+  runs: HostedAutomationRunEvidence[]
+}
+
+export interface ReconciledHostedAutomationRun {
+  actor: HostedAutomationActor
+  run: AutomationRun
 }
 
 type Sql = postgres.Sql
@@ -25,6 +32,7 @@ type AutomationRow = {
 type RunRow = {
   id: string; automation_id: string; invocation_id: string; dispatch_request_id: string; dispatch_receipt: AutomationRun["dispatchReceipt"]; session_id: string | null; status: AutomationRun["status"]; trigger: AutomationRun["trigger"]; scheduled_for: Date | string | null; started_at: Date | string | null; completed_at: Date | string | null; duration_ms: number | null; input_tokens: number | null; output_tokens: number | null; total_tokens: number | null; prompt_snapshot: string; model_snapshot: string; error: string | null; created_at: Date | string; updated_at: Date | string
 }
+type ScheduleRunRow = Pick<RunRow, "automation_id" | "status" | "trigger" | "scheduled_for">
 
 /** Hosted metadata store bound to one verified actor; prompt bodies live in the actor's Workspace. */
 export class PostgresAutomationStore implements AutomationStore {
@@ -169,25 +177,52 @@ export class PostgresAutomationStore implements AutomationStore {
     }
   }
 
+  async claimRunForDispatch(runId: string): Promise<AutomationRun | null> {
+    const rows = await this.sql<RunRow[]>`
+      UPDATE boring_automation_runs
+      SET status = 'dispatching', updated_at = NOW()
+      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId} AND status = 'queued'
+      RETURNING *
+    `
+    return rows[0] ? toRun(rows[0]) : null
+  }
+
+  async heartbeatRun(runId: string): Promise<boolean> {
+    const result = await this.sql`
+      UPDATE boring_automation_runs
+      SET updated_at = NOW()
+      WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+        AND status IN ('queued', 'dispatching', 'running')
+    `
+    return result.count > 0
+  }
+
   async updateRunLifecycle(runId: string, patch: AutomationRunLifecyclePatch): Promise<AutomationRun> {
     const current = await this.findRun(runId)
     if (!current) throw runNotFound(runId)
-    const next = { ...current, ...patch, updatedAt: this.clock().toISOString() }
+    if (current.status !== "queued" && current.status !== "dispatching" && current.status !== "running") throw runLeaseLost(runId)
+    const next = { ...current, ...patch }
+    const dispatchReceipt = next.dispatchReceipt === null ? null : JSON.stringify(next.dispatchReceipt)
     const rows = await this.sql<RunRow[]>`
       UPDATE boring_automation_runs
-      SET session_id = ${next.sessionId}, dispatch_receipt = ${next.dispatchReceipt === null ? null : this.sql.json(next.dispatchReceipt as never)}, status = ${next.status}, started_at = ${next.startedAt}, completed_at = ${next.completedAt}, duration_ms = ${next.durationMs}, input_tokens = ${next.inputTokens}, output_tokens = ${next.outputTokens}, total_tokens = ${next.totalTokens}, error = ${next.error}, updated_at = ${next.updatedAt}
+      SET session_id = ${next.sessionId}, dispatch_receipt = ${dispatchReceipt}::text::jsonb, status = ${next.status}, started_at = ${next.startedAt}, completed_at = ${next.completedAt}, duration_ms = ${next.durationMs}, input_tokens = ${next.inputTokens}, output_tokens = ${next.outputTokens}, total_tokens = ${next.totalTokens}, error = ${next.error}, updated_at = NOW()
       WHERE id = ${runId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
+        AND status = ${current.status}
       RETURNING *
     `
-    if (!rows[0]) throw runNotFound(runId)
+    if (!rows[0]) {
+      if (await this.findRun(runId)) throw runLeaseLost(runId)
+      throw runNotFound(runId)
+    }
     return toRun(rows[0])
   }
 
-  async listRuns(automationId: string): Promise<AutomationRun[]> {
+  async listRuns(automationId: string, limit?: number): Promise<AutomationRun[]> {
     const rows = await this.sql<RunRow[]>`
       SELECT * FROM boring_automation_runs
       WHERE automation_id = ${automationId} AND workspace_id = ${this.actor.workspaceId} AND owner_user_id = ${this.actor.userId}
       ORDER BY created_at DESC, id DESC
+      LIMIT ${limit ?? 2_147_483_647}
     `
     return rows.map(toRun)
   }
@@ -212,20 +247,58 @@ export class PostgresAutomationStore implements AutomationStore {
   }
 }
 
-export async function listHostedAutomationCandidates(sql: Sql): Promise<HostedAutomationCandidate[]> {
+export async function reconcileStaleHostedAutomationRuns(
+  sql: Sql,
+  staleAfterMs: number,
+): Promise<ReconciledHostedAutomationRun[]> {
+  const rows = await sql<(RunRow & { workspace_id: string; owner_user_id: string })[]>`
+    UPDATE boring_automation_runs
+    SET status = CASE WHEN status = 'dispatching' AND dispatch_receipt IS NULL THEN 'outcome-unknown' ELSE 'failed' END,
+        completed_at = NOW(),
+        error = CASE WHEN status = 'dispatching' AND dispatch_receipt IS NULL
+          THEN 'Automation dispatch outcome is unknown after its worker lease expired; it was not retried'
+          ELSE 'Automation worker lease expired before the run completed' END,
+        updated_at = NOW()
+    WHERE status IN ('queued', 'dispatching', 'running')
+      AND updated_at < NOW() - (${staleAfterMs} * INTERVAL '1 millisecond')
+    RETURNING *
+  `
+  return rows.map((row) => ({
+    actor: { workspaceId: row.workspace_id, userId: row.owner_user_id },
+    run: toRun(row),
+  }))
+}
+
+export async function listHostedAutomationCandidates(sql: Sql, scheduledFor: string): Promise<HostedAutomationCandidate[]> {
   const automationRows = await sql<(AutomationRow & { workspace_id: string; owner_user_id: string })[]>`
     SELECT id, workspace_id, owner_user_id, title, enabled, cron, timezone, model, created_at, updated_at
     FROM boring_automation_automations
     WHERE deleted_at IS NULL
     ORDER BY id
   `
-  const runRows = await sql<(RunRow & { workspace_id: string; owner_user_id: string })[]>`
-    SELECT * FROM boring_automation_runs ORDER BY automation_id, created_at DESC, id DESC
+  const runRows = await sql<ScheduleRunRow[]>`
+    SELECT runs.automation_id, runs.status, runs.trigger, runs.scheduled_for
+    FROM boring_automation_runs AS runs
+    INNER JOIN boring_automation_automations AS automations
+      ON automations.id = runs.automation_id
+      AND automations.workspace_id = runs.workspace_id
+      AND automations.owner_user_id = runs.owner_user_id
+    WHERE automations.deleted_at IS NULL
+      AND (
+        runs.status IN ('queued', 'dispatching', 'running')
+        OR (runs.trigger = 'scheduled' AND runs.scheduled_for = ${scheduledFor})
+      )
+    ORDER BY runs.automation_id
   `
-  const runsByAutomation = new Map<string, AutomationRun[]>()
+  const runsByAutomation = new Map<string, HostedAutomationRunEvidence[]>()
   for (const row of runRows) {
     const list = runsByAutomation.get(row.automation_id) ?? []
-    list.push(toRun(row))
+    list.push({
+      automationId: row.automation_id,
+      status: row.status,
+      trigger: row.trigger,
+      scheduledFor: nullableIso(row.scheduled_for),
+    })
     runsByAutomation.set(row.automation_id, list)
   }
   return automationRows.map((row) => ({
diff --git a/plugins/boring-automation/src/server/routes.ts b/plugins/boring-automation/src/server/routes.ts
index f31a46725..39c036857 100644
--- a/plugins/boring-automation/src/server/routes.ts
+++ b/plugins/boring-automation/src/server/routes.ts
@@ -1,5 +1,5 @@
 import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify"
-import { ZodError, type ZodSchema } from "zod"
+import { z, ZodError, type ZodSchema } from "zod"
 import {
   AutomationCreateSchema,
   AutomationPatchSchema,
@@ -11,9 +11,14 @@ import {
 import type { HostedDueRunService } from "./hostedDueRunService"
 import type { DueRunService } from "./dueRunService"
 import { timingSafeEqual } from "node:crypto"
-import { ManualRunExecutor } from "./manualRunExecutor"
+import { ManualRunExecutor, type VerifiedAutomationActor } from "./manualRunExecutor"
+import type { AutomationRunEventBus } from "./runEventBus"
 import { AutomationStoreError, automationNotFound, type AutomationStore } from "./store"
 
+const RunListQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(1_000).optional(),
+}).strict()
+
 export interface AutomationRoutesOptions {
   store: AutomationStore
   storeForRequest?: (request: FastifyRequest) => Promise<AutomationStore> | AutomationStore
@@ -23,10 +28,56 @@ export interface AutomationRoutesOptions {
   dueRunServiceForRequest?: (request: FastifyRequest) => Promise<Pick<DueRunService, "runDue">> | Pick<DueRunService, "runDue">
   hostedDueRunService?: Pick<HostedDueRunService, "runDue">
   hostedTriggerToken?: string
+  actorResolver?: (request: FastifyRequest) => Promise<VerifiedAutomationActor> | VerifiedAutomationActor
+  eventBus?: AutomationRunEventBus
 }
 
 export async function automationRoutes(app: FastifyInstance, opts: AutomationRoutesOptions): Promise<void> {
-  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`, async (_request, reply) => {
+  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/events`, async (request, reply) => {
+    let closed = false
+    let opened = false
+    let unsubscribe: (() => void) | undefined
+    let heartbeat: ReturnType<typeof setInterval> | undefined
+    const cleanup = () => {
+      if (closed) return
+      closed = true
+      if (heartbeat !== undefined) clearInterval(heartbeat)
+      unsubscribe?.()
+    }
+    reply.raw.once("close", cleanup)
+    try {
+      if (!opts.actorResolver || !opts.eventBus) {
+        throw new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_EXECUTOR_UNAVAILABLE, "automation event stream is unavailable")
+      }
+      const actor = await opts.actorResolver(request)
+      if (closed) return
+      const subscribed = await opts.eventBus.subscribe(actor, (event) => {
+        if (opened && !closed && !reply.raw.destroyed) reply.raw.write(sseFrame("run.changed", event))
+      })
+      if (closed) {
+        subscribed()
+        return
+      }
+      unsubscribe = subscribed
+      reply.hijack()
+      reply.raw.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+      })
+      opened = true
+      reply.raw.write(sseFrame("ready", { v: 1 }))
+      heartbeat = setInterval(() => {
+        if (!reply.raw.destroyed) reply.raw.write(": heartbeat\n\n")
+      }, 25_000)
+      heartbeat.unref?.()
+    } catch (cause) {
+      if (!closed) return sendError(reply, cause)
+    }
+  })
+
+  app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations`,  async (_request, reply) => {
     try {
       return { ok: true, automations: await (await resolveStore(opts, _request)).listAutomations() }
     } catch (cause) {
@@ -146,13 +197,18 @@ export async function automationRoutes(app: FastifyInstance, opts: AutomationRou
   app.get(`${BORING_AUTOMATION_ROUTE_PREFIX}/automations/:id/runs`, async (request, reply) => {
     try {
       const { id } = parseParams(IdParamsSchema, request.params)
-      return { ok: true, runs: await (await resolveStore(opts, request)).listRuns(id) }
+      const { limit } = parse(RunListQuerySchema, request.query)
+      return { ok: true, runs: await (await resolveStore(opts, request)).listRuns(id, limit) }
     } catch (cause) {
       return sendError(reply, cause)
     }
   })
 }
 
+function sseFrame(event: string, data: unknown): string {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+}
+
 async function resolveStore(opts: AutomationRoutesOptions, request: FastifyRequest): Promise<AutomationStore> {
   return await opts.storeForRequest?.(request) ?? opts.store
 }
@@ -217,6 +273,7 @@ function httpStatusForStoreError(error: AutomationStoreError): number {
       return 404
     case BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE:
     case BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED:
+    case BORING_AUTOMATION_ERROR_CODES.RUN_LEASE_LOST:
     case BORING_AUTOMATION_ERROR_CODES.TOOL_ABORTED:
       return 409
     case BORING_AUTOMATION_ERROR_CODES.TRIGGER_FORBIDDEN:
diff --git a/plugins/boring-automation/src/server/runEventBus.ts b/plugins/boring-automation/src/server/runEventBus.ts
new file mode 100644
index 000000000..386314596
--- /dev/null
+++ b/plugins/boring-automation/src/server/runEventBus.ts
@@ -0,0 +1,110 @@
+import type postgres from "postgres"
+import type { AutomationRunChangedEvent } from "../shared/types"
+import type { VerifiedAutomationActor } from "./manualRunExecutor"
+
+const AUTOMATION_RUN_EVENT_CHANNEL = "boring_automation_run_changed"
+
+type RunEventListener = (event: AutomationRunChangedEvent) => void
+
+export interface AutomationRunEventPublisher {
+  publish(event: AutomationRunChangedEvent): Promise<void>
+}
+
+export interface AutomationRunEventBus extends AutomationRunEventPublisher {
+  subscribe(actor: VerifiedAutomationActor, listener: RunEventListener): Promise<() => void>
+  close(): Promise<void>
+}
+
+export class InMemoryAutomationRunEventBus implements AutomationRunEventBus {
+  private readonly subscribers = new Set<{ actor: VerifiedAutomationActor; listener: RunEventListener }>()
+
+  async publish(event: AutomationRunChangedEvent): Promise<void> {
+    for (const subscriber of this.subscribers) {
+      if (matchesActor(event, subscriber.actor)) subscriber.listener(event)
+    }
+  }
+
+  async subscribe(actor: VerifiedAutomationActor, listener: RunEventListener): Promise<() => void> {
+    const subscriber = { actor: { ...actor }, listener }
+    this.subscribers.add(subscriber)
+    return () => this.subscribers.delete(subscriber)
+  }
+
+  async close(): Promise<void> {
+    this.subscribers.clear()
+  }
+}
+
+export class PostgresAutomationRunEventBus implements AutomationRunEventBus {
+  private readonly subscribers = new Set<{ actor: VerifiedAutomationActor; listener: RunEventListener }>()
+  private listener: Promise<postgres.ListenMeta> | undefined
+
+  constructor(private readonly sql: postgres.Sql) {}
+
+  async publish(event: AutomationRunChangedEvent): Promise<void> {
+    await this.sql.notify(AUTOMATION_RUN_EVENT_CHANNEL, JSON.stringify(event))
+  }
+
+  async subscribe(actor: VerifiedAutomationActor, listener: RunEventListener): Promise<() => void> {
+    const subscriber = { actor: { ...actor }, listener }
+    this.subscribers.add(subscriber)
+    try {
+      await this.ensureListening()
+    } catch (error) {
+      this.subscribers.delete(subscriber)
+      throw error
+    }
+    return () => this.subscribers.delete(subscriber)
+  }
+
+  async close(): Promise<void> {
+    this.subscribers.clear()
+    const listener = this.listener
+    this.listener = undefined
+    if (listener) await (await listener).unlisten()
+  }
+
+  private ensureListening(): Promise<postgres.ListenMeta> {
+    this.listener ??= this.sql.listen(AUTOMATION_RUN_EVENT_CHANNEL, (payload) => {
+      const event = parseAutomationRunChangedEvent(payload)
+      if (!event) return
+      for (const subscriber of this.subscribers) {
+        if (matchesActor(event, subscriber.actor)) subscriber.listener(event)
+      }
+    })
+    return this.listener
+  }
+}
+
+function matchesActor(event: AutomationRunChangedEvent, actor: VerifiedAutomationActor): boolean {
+  return event.workspaceId === actor.workspaceId && event.userId === actor.userId
+}
+
+export function parseAutomationRunChangedEvent(payload: string): AutomationRunChangedEvent | null {
+  try {
+    const value = JSON.parse(payload) as Partial<AutomationRunChangedEvent>
+    if (
+      value.v !== 1
+      || typeof value.eventId !== "string"
+      || typeof value.workspaceId !== "string"
+      || typeof value.userId !== "string"
+      || typeof value.automationId !== "string"
+      || typeof value.runId !== "string"
+      || typeof value.updatedAt !== "string"
+      || !isRunStatus(value.status)
+    ) return null
+    return value as AutomationRunChangedEvent
+  } catch {
+    return null
+  }
+}
+
+function isRunStatus(value: unknown): value is AutomationRunChangedEvent["status"] {
+  return value === "queued"
+    || value === "dispatching"
+    || value === "running"
+    || value === "succeeded"
+    || value === "failed"
+    || value === "cancelled"
+    || value === "outcome-unknown"
+}
diff --git a/plugins/boring-automation/src/server/store.ts b/plugins/boring-automation/src/server/store.ts
index f95170a1e..439b73077 100644
--- a/plugins/boring-automation/src/server/store.ts
+++ b/plugins/boring-automation/src/server/store.ts
@@ -31,8 +31,10 @@ export interface AutomationStore {
   // Executor-owned operations. Public HTTP routes expose run history read-only.
   reconcileOrphanedRuns(automationId: string): Promise<void>
   beginRun(input: AutomationRunBegin): Promise<AutomationRun>
+  claimRunForDispatch(runId: string): Promise<AutomationRun | null>
+  heartbeatRun(runId: string): Promise<boolean>
   updateRunLifecycle(runId: string, patch: AutomationRunLifecyclePatch): Promise<AutomationRun>
-  listRuns(automationId: string): Promise<AutomationRun[]>
+  listRuns(automationId: string, limit?: number): Promise<AutomationRun[]>
 }
 
 export class AutomationStoreError extends Error {
@@ -56,6 +58,10 @@ export function runAlreadyActive(automationId: string): AutomationStoreError {
   return new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_ACTIVE, `automation ${automationId} already has an active run`)
 }
 
+export function runLeaseLost(runId: string): AutomationStoreError {
+  return new AutomationStoreError(BORING_AUTOMATION_ERROR_CODES.RUN_LEASE_LOST, `automation run ${runId} no longer owns an active lease`)
+}
+
 export function runAlreadyRecorded(automationId: string, scheduledFor: string): AutomationStoreError {
   return new AutomationStoreError(
     BORING_AUTOMATION_ERROR_CODES.RUN_ALREADY_RECORDED,
diff --git a/plugins/boring-automation/src/shared/__tests__/schedule.test.ts b/plugins/boring-automation/src/shared/__tests__/schedule.test.ts
index 0c500aedc..f6fc78451 100644
--- a/plugins/boring-automation/src/shared/__tests__/schedule.test.ts
+++ b/plugins/boring-automation/src/shared/__tests__/schedule.test.ts
@@ -81,7 +81,7 @@ describe("evaluateAutomationSchedule", () => {
     expect(missed.decisions).toEqual([expect.objectContaining({ kind: "skip", reason: "not-current-minute" })])
   })
 
-  it("skips disabled automations, duplicates for the scheduled instant, and active queued or running runs", () => {
+  it("skips disabled automations, duplicates for the scheduled instant, and active runs", () => {
     const now = "2026-01-01T09:00:15.000Z"
     expect(evaluateAt(now, [automation({ enabled: false })]).decisions).toEqual([
       expect.objectContaining({ kind: "skip", reason: "disabled", scheduledFor: null }),
@@ -91,9 +91,11 @@ describe("evaluateAutomationSchedule", () => {
       expect.objectContaining({ kind: "skip", reason: "duplicate-scheduled-run", scheduledFor: "2026-01-01T09:00:00.000Z" }),
     ])
 
-    expect(evaluateAt(now, [automation()], [run({ trigger: "manual", scheduledFor: null, status: "running" })]).decisions).toEqual([
-      expect.objectContaining({ kind: "skip", reason: "active-run", scheduledFor: "2026-01-01T09:00:00.000Z" }),
-    ])
+    for (const status of ["queued", "dispatching", "running"] as const) {
+      expect(evaluateAt(now, [automation()], [run({ trigger: "manual", scheduledFor: null, status })]).decisions).toEqual([
+        expect.objectContaining({ kind: "skip", reason: "active-run", scheduledFor: "2026-01-01T09:00:00.000Z" }),
+      ])
+    }
   })
 
   it("skips spring DST nonexistent local minutes", () => {
diff --git a/plugins/boring-automation/src/shared/error-codes.ts b/plugins/boring-automation/src/shared/error-codes.ts
index 0413ede00..d337c624f 100644
--- a/plugins/boring-automation/src/shared/error-codes.ts
+++ b/plugins/boring-automation/src/shared/error-codes.ts
@@ -7,6 +7,7 @@ export const BORING_AUTOMATION_ERROR_CODES = {
   RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND",
   RUN_ALREADY_ACTIVE: "BORING_AUTOMATION_RUN_ALREADY_ACTIVE",
   RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
+  RUN_LEASE_LOST: "BORING_AUTOMATION_RUN_LEASE_LOST",
   RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
   TOOL_CONTEXT_UNAVAILABLE: "BORING_AUTOMATION_TOOL_CONTEXT_UNAVAILABLE",
   TOOL_ABORTED: "BORING_AUTOMATION_TOOL_ABORTED",
diff --git a/plugins/boring-automation/src/shared/schedule.ts b/plugins/boring-automation/src/shared/schedule.ts
index 9749e16da..804e9f762 100644
--- a/plugins/boring-automation/src/shared/schedule.ts
+++ b/plugins/boring-automation/src/shared/schedule.ts
@@ -42,7 +42,7 @@ export type AutomationScheduleDecision = AutomationScheduleDueDecision | Automat
 
 export interface EvaluateAutomationScheduleInput {
   automations: readonly Automation[]
-  runs: readonly AutomationRun[]
+  runs: readonly Pick<AutomationRun, "automationId" | "status" | "trigger" | "scheduledFor">[]
   now: Date
 }
 
@@ -123,12 +123,14 @@ function skip(
   return { kind: "skip", automation, automationId: automation.id, scheduledFor, reason, message }
 }
 
-function hasDuplicateScheduledRun(runs: readonly AutomationRun[], automationId: string, scheduledFor: string): boolean {
+function hasDuplicateScheduledRun(runs: EvaluateAutomationScheduleInput["runs"], automationId: string, scheduledFor: string): boolean {
   return runs.some((run) => run.automationId === automationId && run.trigger === "scheduled" && run.scheduledFor === scheduledFor)
 }
 
-function hasActiveRun(runs: readonly AutomationRun[], automationId: string): boolean {
-  return runs.some((run) => run.automationId === automationId && (run.status === "queued" || run.status === "running"))
+function hasActiveRun(runs: EvaluateAutomationScheduleInput["runs"], automationId: string): boolean {
+  return runs.some((run) => run.automationId === automationId && (
+    run.status === "queued" || run.status === "dispatching" || run.status === "running"
+  ))
 }
 
 function floorToMinute(date: Date): Date {
diff --git a/plugins/boring-automation/src/shared/types.ts b/plugins/boring-automation/src/shared/types.ts
index 5ff078d78..aeefae00d 100644
--- a/plugins/boring-automation/src/shared/types.ts
+++ b/plugins/boring-automation/src/shared/types.ts
@@ -1,6 +1,17 @@
 export type AutomationRunStatus = "queued" | "dispatching" | "running" | "succeeded" | "failed" | "cancelled" | "outcome-unknown"
 export type AutomationRunTrigger = "manual" | "scheduled"
 
+export interface AutomationRunChangedEvent {
+  v: 1
+  eventId: string
+  workspaceId: string
+  userId: string
+  automationId: string
+  runId: string
+  status: AutomationRunStatus
+  updatedAt: string
+}
+
 export interface Automation {
   id: string
   title: string
diff --git a/tools/ui-review/fixtures/workspace-components/src/fixtures.tsx b/tools/ui-review/fixtures/workspace-components/src/fixtures.tsx
index 53f6f7e99..cd4caf561 100644
--- a/tools/ui-review/fixtures/workspace-components/src/fixtures.tsx
+++ b/tools/ui-review/fixtures/workspace-components/src/fixtures.tsx
@@ -186,6 +186,9 @@ const AUTOMATION_RUNS: AutomationRun[] = []
 
 function AutomationPaneFixture() {
   const client = useMemo<AutomationClient>(() => ({
+    subscribeRunEvents: async (_onEvent, options = {}) => await new Promise<void>((resolve) => {
+      options.signal?.addEventListener("abort", () => resolve(), { once: true })
+    }),
     listAutomations: async () => AUTOMATIONS,
     createAutomation: async (input) => ({ ...AUTOMATIONS[0]!, ...input, id: "created-automation" }),
     getAutomation: async (id) => AUTOMATIONS.find((automation) => automation.id === id) ?? AUTOMATIONS[0]!,

From ac4117039fd2f8a7893d414834f94c1f25e9a844 Mon Sep 17 00:00:00 2001
From: hachej <julien.hurault@sumeo.io>
Date: Fri, 31 Jul 2026 15:15:44 +0000
Subject: [PATCH 2/2] #909 fix(full-app): restore addressed fleet discovery

---
 apps/full-app/src/front/main.test.ts | 1 +
 apps/full-app/src/front/main.tsx     | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/full-app/src/front/main.test.ts b/apps/full-app/src/front/main.test.ts
index 4851ae273..5b47bb121 100644
--- a/apps/full-app/src/front/main.test.ts
+++ b/apps/full-app/src/front/main.test.ts
@@ -25,6 +25,7 @@ describe('full-app production chat composition', () => {
     expect(workspaceFrontPropsSource).toMatch(/\baddressedAgentSelection\b/)
     expect(workspaceFrontPropsSource).toMatch(/\buseAddressedAgentSelection=\{useAddressedAgentSelection\}/)
     expect(workspaceFrontPropsSource).toMatch(/\bworkspaceLayout="plugin-tabs"/)
+    expect(workspaceFrontPropsSource).not.toMatch(/\bagentTypeId\s*=/)
     expect(chatParamsSource).not.toMatch(/\bagentTypeId\s*:/)
     expect(source).toMatch(/\bchatParams=\{chatParams\}/)
     expect(source).toMatch(/\bchatFirstPublicWorkspaceProps=\{\{[\s\S]*\baddressedAgentSelection:\s*false\b/)
diff --git a/apps/full-app/src/front/main.tsx b/apps/full-app/src/front/main.tsx
index 64e037b6d..3f46445ff 100644
--- a/apps/full-app/src/front/main.tsx
+++ b/apps/full-app/src/front/main.tsx
@@ -124,7 +124,6 @@ const chatParams = {
 createRoot(document.getElementById('root')!).render(
   <>
     <CoreWorkspaceAgentFront
-      agentTypeId="default"
       plugins={fullAppFrontPlugins}
       apiBaseUrl=""
       apiTimeout={10_000}