diff --git a/packages/app/e2e/automations/automations-panel.spec.ts b/packages/app/e2e/automations/automations-panel.spec.ts
index 70530ea63..2b3759d5b 100644
--- a/packages/app/e2e/automations/automations-panel.spec.ts
+++ b/packages/app/e2e/automations/automations-panel.spec.ts
@@ -109,6 +109,30 @@ async function openAutomations(page: Parameters<typeof openSidebar>[0]) {
   return surface
 }
 
+async function expectInternalHoverSurface(locator: ReturnType<Page["locator"]>) {
+  await locator.hover()
+  await expect
+    .poll(async () =>
+      locator.evaluate((element) => {
+        const style = getComputedStyle(element)
+        return {
+          backgroundColor: style.backgroundColor,
+          cursor: style.cursor,
+          height: Math.round(element.getBoundingClientRect().height),
+          textDecorationLine: style.textDecorationLine,
+        }
+      }),
+    )
+    .toMatchObject({
+      cursor: "default",
+      height: 30,
+      textDecorationLine: "none",
+    })
+  await expect
+    .poll(async () => locator.evaluate((element) => getComputedStyle(element).backgroundColor))
+    .not.toBe("rgba(0, 0, 0, 0)")
+}
+
 test("automations panel: create manually adds an automation", async ({ page, project }) => {
   test.setTimeout(120_000)
 
@@ -595,19 +619,15 @@ test("automations panel: detail moves an automation to another open project", as
     const detail = surface.locator('[data-component="automation-detail"]')
     await expect(detail).toBeVisible()
 
-    // The Project row is a picker when another project is open. Moving is a
-    // create-in-target + delete-from-source pair: the automation appears in
-    // the target project's list, vanishes from the source, and the detail
-    // stays open on the recreated definition (new id, same fields).
+    // The Project row is a picker when another project is open. Moving updates
+    // the same automation in place: it appears in the target project's list,
+    // vanishes from the source, and the detail stays open on the same id.
     await detail.locator('[data-action="automation-edit-project"]').click()
     await page.locator(`[data-project="${otherProjectID}"]`).click()
 
     await expect
-      .poll(async () =>
-        ((await otherSDK.automation.list()).data?.items ?? []).filter((item) => item.title === "Migrating digest")
-          .length,
-      )
-      .toBe(1)
+      .poll(async () => ((await otherSDK.automation.list()).data?.items ?? []).find((item) => item.id === created.id))
+      .toMatchObject({ id: created.id, title: "Migrating digest" })
     await expect
       .poll(async () =>
         ((await project.sdk.automation.list()).data?.items ?? []).filter((item) => item.id === created.id).length,
@@ -620,6 +640,62 @@ test("automations panel: detail moves an automation to another open project", as
   }
 })
 
+test("automations panel: detail project picker stays available with one open project", async ({ page, project }) => {
+  test.setTimeout(120_000)
+
+  await project.open()
+
+  const projectID = (await project.sdk.project.current()).data!.id
+  await project.sdk.automation.create(
+    recurring(projectID, "Single project digest", "Summarize the current project.", "0 9 * * *"),
+  )
+
+  const surface = await openAutomations(page)
+  await surface.locator('[data-action="automation-row"]', { hasText: "Single project digest" }).first().click()
+
+  const detail = surface.locator('[data-component="automation-detail"]')
+  await expect(detail).toBeVisible()
+
+  const projectPicker = detail.locator('[data-action="automation-edit-project"]')
+  await expect(projectPicker).toBeVisible()
+
+  await expectInternalHoverSurface(projectPicker)
+  await expectInternalHoverSurface(detail.locator('[data-action="automation-edit-schedule"]'))
+  await expectInternalHoverSurface(detail.locator('[data-action="automation-edit-model"]'))
+
+  await projectPicker.click()
+  const menu = page.locator('[role="menu"][aria-label="Workspace"]')
+  await expect(menu).toBeVisible()
+  await expect(menu.locator(`[data-project="${projectID}"]`)).toBeVisible()
+  await menu.locator('[data-action="automation-folder-open-project"]').click()
+  await expect(menu).toBeHidden()
+  const directoryDialog = page.getByRole("dialog").filter({ has: page.getByPlaceholder("Search folders") })
+  await expect(directoryDialog).toBeVisible()
+  await expect(surface).toBeVisible()
+  expect(new URL(page.url()).pathname).toBe("/automations")
+})
+
+test("automations panel: continue automation project stays read-only", async ({ page, project, assistant }) => {
+  test.setTimeout(120_000)
+
+  await project.open()
+  await assistant.tool("automate", {
+    title: "Continue project loop",
+    prompt: "Keep checking the same conversation.",
+    cron: "0 8 * * *",
+    continueSession: true,
+  })
+  await project.prompt("Loop this conversation every morning.")
+
+  const surface = await openAutomations(page)
+  await surface.locator('[data-action="automation-row"]', { hasText: "Continue project loop" }).first().click()
+
+  const detail = surface.locator('[data-component="automation-detail"]')
+  await expect(detail).toBeVisible()
+  await expect(detail.locator('[data-action="automation-edit-project"]')).toHaveCount(0)
+  await expectInternalHoverSurface(detail.locator('[data-action="automation-open-source"]'))
+})
+
 test("automations panel: a rhythm the picker cannot express is read-only", async ({ page, project }) => {
   test.setTimeout(120_000)
 
@@ -670,12 +746,10 @@ test("automations panel: a paused automation arrives paused after a move", async
     await detail.locator('[data-action="automation-edit-project"]').click()
     await page.locator(`[data-project="${otherProjectID}"]`).click()
 
-    // The recreated copy must keep the silence the user set, not wake up live.
+    // The moved definition must keep the silence the user set, not wake up live.
     await expect
       .poll(async () => {
-        const moved = ((await otherSDK.automation.list()).data?.items ?? []).find(
-          (item) => item.title === "Silenced digest",
-        )
+        const moved = ((await otherSDK.automation.list()).data?.items ?? []).find((item) => item.id === created.id)
         return moved ? moved.paused : "missing"
       })
       .toBe(true)
@@ -687,7 +761,7 @@ test("automations panel: a paused automation arrives paused after a move", async
   }
 })
 
-test("automations panel: a failed pause during a move rolls back and keeps the source", async ({
+test("automations panel: a failed move keeps the source", async ({
   page,
   project,
   backend,
@@ -713,10 +787,10 @@ test("automations panel: a failed pause during a move rolls back and keeps the s
     const detail = surface.locator('[data-component="automation-detail"]')
     await expect(detail).toBeVisible()
 
-    // Re-applying the pause on the target fails. The move must fail as a whole:
-    // the fresh copy is deleted, the paused source is untouched, and the user
-    // is told — never a silenced automation suddenly live in another project.
-    await page.route("**/automation/*/pause*", (route) => route.fulfill({ status: 500, body: "{}" }))
+    await page.route(`**/automation/${created.id}`, (route) => {
+      if (route.request().method() !== "PUT") return route.continue()
+      return route.fulfill({ status: 500, body: "{}" })
+    })
     await detail.locator('[data-action="automation-edit-project"]').click()
     await page.locator(`[data-project="${otherProjectID}"]`).click()
 
diff --git a/packages/app/src/context/global-sync.tsx b/packages/app/src/context/global-sync.tsx
index 49962f502..5f7056447 100644
--- a/packages/app/src/context/global-sync.tsx
+++ b/packages/app/src/context/global-sync.tsx
@@ -37,6 +37,7 @@ import { createPendingQuestionController } from "./global-sync/pending-question-
 import { pendingSessionIDsForDirectory, type PendingQuestionIndex } from "./global-sync/pending-question-index"
 import {
   applyAutomationDefinition,
+  applyAutomationMoveResult,
   applyAutomationRun,
   applyAutomationTombstone,
   mergeAutomationRuns,
@@ -445,6 +446,38 @@ function createGlobalSync() {
     }
   }
 
+  async function moveAutomation(directory: string, automationID: string, targetProject: { id: string; worktree: string }) {
+    children.pin(directory)
+    children.pin(targetProject.worktree)
+    try {
+      const source = children.peek(directory, { bootstrap: false })
+      const current = source[0].automation[automationID]
+      const res = await sdkFor(directory).automation.update({
+        automationID,
+        automationUpdateInput: {
+          where: {
+            projectID: targetProject.id,
+            ...(current?.where.worktree ? { worktree: current.where.worktree } : {}),
+          },
+        },
+      })
+      if (res.data) {
+        const target = children.peek(targetProject.worktree, { bootstrap: false })
+        applyAutomationMoveResult({
+          source,
+          target,
+          automationID,
+          targetProjectID: targetProject.id,
+          incoming: res.data,
+        })
+      }
+      return res.data
+    } finally {
+      children.unpin(targetProject.worktree)
+      children.unpin(directory)
+    }
+  }
+
   async function bootstrapInstance(directory: string) {
     if (!directory) return
     const pending = booting.get(directory)
@@ -708,6 +741,7 @@ function createGlobalSync() {
     automation: {
       create: createAutomation,
       update: updateAutomation,
+      move: moveAutomation,
       loadRuns: loadAutomationRuns,
       pause: pauseAutomation,
       resume: resumeAutomation,
diff --git a/packages/app/src/context/global-sync/automation-store.test.ts b/packages/app/src/context/global-sync/automation-store.test.ts
index 78a013bed..c9021a40c 100644
--- a/packages/app/src/context/global-sync/automation-store.test.ts
+++ b/packages/app/src/context/global-sync/automation-store.test.ts
@@ -4,6 +4,7 @@ import { createStore } from "solid-js/store"
 import type { State } from "./types"
 import {
   applyAutomationDefinition,
+  applyAutomationMoveResult,
   applyAutomationRun,
   applyAutomationTombstone,
   canAcceptAutomationDefinition,
@@ -12,7 +13,7 @@ import {
   mergeAutomationList,
 } from "./automation-store"
 
-const definition = (input: { id: string; revision: number; title?: string; paused?: boolean }): AutomationDefinition =>
+const definition = (input: { id: string; revision: number; title?: string; paused?: boolean; projectID?: string }): AutomationDefinition =>
   ({
     kind: "recurring",
     id: input.id,
@@ -21,7 +22,7 @@ const definition = (input: { id: string; revision: number; title?: string; pause
     revision: input.revision,
     paused: input.paused ?? false,
     context: "fresh",
-    where: { projectID: "prj_1" },
+    where: { projectID: input.projectID ?? "prj_1" },
     createdAt: 1,
     updatedAt: 1,
     timezone: "UTC",
@@ -145,6 +146,46 @@ describe("applyAutomationTombstone", () => {
   })
 })
 
+describe("applyAutomationMoveResult", () => {
+  test("tombstones the source and writes the target only after the response confirms the target project", () => {
+    const [source, setSource] = createStore(baseState({ automation: { a: definition({ id: "a", revision: 1, projectID: "source" }) } }))
+    const [target, setTarget] = createStore(baseState())
+    const moved = definition({ id: "a", revision: 2, projectID: "target" })
+
+    const applied = applyAutomationMoveResult({
+      source: [source, setSource],
+      target: [target, setTarget],
+      automationID: "a",
+      targetProjectID: "target",
+      incoming: moved,
+    })
+
+    expect(applied).toBe("target")
+    expect(source.automation["a"]).toBeUndefined()
+    expect(source.automation_tombstone["a"]).toBe(2)
+    expect(target.automation["a"]).toBe(moved)
+  })
+
+  test("falls back to the source update when a stale target does not match the response project", () => {
+    const [source, setSource] = createStore(baseState({ automation: { a: definition({ id: "a", revision: 1, projectID: "source" }) } }))
+    const [target, setTarget] = createStore(baseState())
+    const response = definition({ id: "a", revision: 2, projectID: "actual" })
+
+    const applied = applyAutomationMoveResult({
+      source: [source, setSource],
+      target: [target, setTarget],
+      automationID: "a",
+      targetProjectID: "stale",
+      incoming: response,
+    })
+
+    expect(applied).toBe("source")
+    expect(source.automation["a"]).toEqual(response)
+    expect(source.automation_tombstone["a"]).toBeUndefined()
+    expect(target.automation["a"]).toBeUndefined()
+  })
+})
+
 describe("applyAutomationRun", () => {
   test("upserts then ignores a stale run", () => {
     const [store, setStore] = createStore(baseState())
diff --git a/packages/app/src/context/global-sync/automation-store.ts b/packages/app/src/context/global-sync/automation-store.ts
index ceedb96b9..9e86a086e 100644
--- a/packages/app/src/context/global-sync/automation-store.ts
+++ b/packages/app/src/context/global-sync/automation-store.ts
@@ -1,6 +1,6 @@
 import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { AutomationDefinition, AutomationDefinitionTombstone, AutomationRun } from "@opencode-ai/sdk/v2/client"
-import type { State } from "./types"
+import type { ChildStoreTuple, State } from "./types"
 
 // Definitions and runs carry a monotonic `revision`; deletions carry a tombstone
 // revision. The HTTP list/get responses and the SSE events share that sequence,
@@ -65,6 +65,28 @@ export function applyAutomationTombstone(
   return true
 }
 
+export function applyAutomationMoveResult(input: {
+  source: ChildStoreTuple
+  target: ChildStoreTuple
+  automationID: string
+  targetProjectID: string
+  incoming: AutomationDefinition
+}): "source" | "target" {
+  const [sourceStore, sourceSetStore] = input.source
+  if (input.incoming.where.projectID !== input.targetProjectID) {
+    applyAutomationDefinition(sourceStore, sourceSetStore, input.incoming)
+    return "source"
+  }
+  applyAutomationTombstone(sourceStore, sourceSetStore, {
+    id: input.automationID,
+    deleted: true,
+    revision: input.incoming.revision,
+  })
+  const [targetStore, targetSetStore] = input.target
+  applyAutomationDefinition(targetStore, targetSetStore, input.incoming)
+  return "target"
+}
+
 export function applyAutomationRun(
   store: Store<State>,
   setStore: SetStoreFunction<State>,
diff --git a/packages/app/src/pages/automations/automation-create-dialog.tsx b/packages/app/src/pages/automations/automation-create-dialog.tsx
index bda28514b..4eecbc68f 100644
--- a/packages/app/src/pages/automations/automation-create-dialog.tsx
+++ b/packages/app/src/pages/automations/automation-create-dialog.tsx
@@ -36,6 +36,7 @@ export function AutomationCreateDialog(props: {
   directory: string
   projectID: string
   template?: AutomationTemplate
+  onOpenProject: () => void
   onCreated: (definition: AutomationDefinition) => void
 }): JSX.Element {
   const globalSync = useGlobalSync()
@@ -216,6 +217,7 @@ export function AutomationCreateDialog(props: {
             <AutomationFolderPicker
               projects={projects()}
               current={directory()}
+              onOpenProject={props.onOpenProject}
               onSelect={(project) => {
                 setDirectory(project.worktree)
                 setProjectID(project.id)
diff --git a/packages/app/src/pages/automations/automation-detail-editors.tsx b/packages/app/src/pages/automations/automation-detail-editors.tsx
index ba165cf50..81aee4e98 100644
--- a/packages/app/src/pages/automations/automation-detail-editors.tsx
+++ b/packages/app/src/pages/automations/automation-detail-editors.tsx
@@ -109,7 +109,7 @@ export function EditableText(props: {
 }
 
 const ROW_VALUE_CLASS =
-  "min-w-0 truncate text-right text-body text-fg-base hover:text-fg-strong hover:underline focus-visible:text-fg-strong focus-visible:underline focus:outline-none cursor-default"
+  "h-[30px] min-w-0 truncate rounded-md px-2 text-right text-body text-fg-base hover:bg-row-hover-overlay hover:text-fg-strong focus-visible:bg-row-hover-overlay focus-visible:text-fg-strong focus:outline-none cursor-default"
 
 function EditorRow(props: { label: string; children: JSX.Element }): JSX.Element {
   return (
@@ -120,18 +120,18 @@ function EditorRow(props: { label: string; children: JSX.Element }): JSX.Element
   )
 }
 
-// The "Project" row: there is no server-side move (each project is its own
-// instance and update rejects a foreign projectID), so "move" is the create
-// card's folder picker driving a create-in-target + delete-from-source pair
-// (see moveToProject in automation-detail). A continue automation stays
-// read-only — it loops inside a conversation that only exists in its source
-// project — as does everything else when no other project is open.
+// The "Project" row moves fresh automations by updating their owner in place.
+// A continue automation stays read-only because it loops inside a conversation
+// that only exists in its source project. Fresh automations keep the picker
+// clickable even with one project, so the user can open another project from
+// this surface before moving it.
 export function ProjectEditorRow(props: {
   directory: Accessor<string>
   automation: Accessor<AutomationDefinition>
   projectName: Accessor<string>
   t: Translate
   onMove: (project: AutomationProject) => void
+  onOpenProject: () => void
 }): JSX.Element {
   const layout = useLayout()
   const projects = createMemo<AutomationProject[]>(() =>
@@ -140,15 +140,11 @@ export function ProjectEditorRow(props: {
       .filter((project) => project.id && project.id !== "global" && project.worktree)
       .map((project) => ({ id: project.id!, worktree: project.worktree, name: project.name })),
   )
-  const movable = createMemo(
-    () =>
-      props.automation().context === "fresh" &&
-      projects().some((project) => project.id !== props.automation().where.projectID),
-  )
+  const editable = createMemo(() => props.automation().context === "fresh" && projects().length > 0)
   return (
     <EditorRow label={props.t("automations.detail.project")}>
       <Show
-        when={movable()}
+        when={editable()}
         fallback={<span class="min-w-0 truncate text-right text-body text-fg-base">{props.projectName()}</span>}
       >
         <AutomationFolderPicker
@@ -157,6 +153,7 @@ export function ProjectEditorRow(props: {
           projects={projects()}
           current={props.directory()}
           onSelect={(project) => props.onMove(project)}
+          onOpenProject={props.onOpenProject}
         />
       </Show>
     </EditorRow>
diff --git a/packages/app/src/pages/automations/automation-detail.tsx b/packages/app/src/pages/automations/automation-detail.tsx
index 48b84d43b..55819611d 100644
--- a/packages/app/src/pages/automations/automation-detail.tsx
+++ b/packages/app/src/pages/automations/automation-detail.tsx
@@ -1,6 +1,5 @@
 import { createEffect, createMemo, createSignal, For, Show, type Accessor, type JSX } from "solid-js"
 import type {
-  AutomationCreateInput,
   AutomationDefinition,
   AutomationRun,
   AutomationUpdateInput,
@@ -110,6 +109,7 @@ export function AutomationDetail(props: {
   projectName: Accessor<string>
   onBack: () => void
   onOpenRun: (sessionID: string) => void
+  onOpenProject: () => void
   onMoved: (definition: AutomationDefinition) => void
 }): JSX.Element {
   const globalSync = useGlobalSync()
@@ -213,43 +213,13 @@ export function AutomationDetail(props: {
     }
   }
 
-  // There is no cross-project move on the server (per-project instances;
-  // update rejects a foreign projectID), so "move" recreates the definition in
-  // the target project, then deletes the source. Create-first so a failure
-  // loses nothing; if the source delete fails (e.g. a run in flight), the
-  // fresh copy is rolled back instead of leaving a duplicate. The id changes
-  // and the run list starts empty — past runs' sessions survive regardless.
   const moveToProject = async (project: AutomationProject) => {
     const previous = props.automation()
     if (busy() || project.id === previous.where.projectID) return
     setBusy(true)
     try {
-      const common = {
-        title: previous.title,
-        prompt: previous.prompt,
-        context: "fresh" as const,
-        where: { projectID: project.id, ...(previous.where.worktree ? { worktree: previous.where.worktree } : {}) },
-        timezone: previous.timezone,
-        model: { providerID: previous.model.providerID, modelID: previous.model.modelID },
-        ...(previous.variant ? { variant: previous.variant } : {}),
-      }
-      const input: AutomationCreateInput =
-        previous.kind === "oneshot"
-          ? { kind: "oneshot", ...common, fireAt: previous.fireAt }
-          : { kind: "recurring", ...common, rhythm: previous.rhythm, stop: previous.stop }
-      const created = await globalSync.automation.create(project.worktree, input)
-      if (!created) return
-      // A paused source must arrive paused: if the target pause fails, the
-      // move fails — roll the copy back rather than leave an automation the
-      // user silenced suddenly live in another project.
-      try {
-        if (previous.paused) await globalSync.automation.pause(project.worktree, created.id)
-        await globalSync.automation.delete(props.directory(), previous.id)
-      } catch (error) {
-        await globalSync.automation.delete(project.worktree, created.id).catch(() => {})
-        throw error
-      }
-      props.onMoved(created)
+      const moved = await globalSync.automation.move(props.directory(), previous.id, project)
+      if (moved) props.onMoved(moved)
     } catch (error) {
       notifyFailure(error)
     } finally {
@@ -356,6 +326,7 @@ export function AutomationDetail(props: {
               projectName={props.projectName}
               t={t}
               onMove={(project) => void moveToProject(project)}
+              onOpenProject={props.onOpenProject}
             />
             <ScheduleEditorRow automation={props.automation} t={t} onPatch={commitPatch} />
             <Show
@@ -369,7 +340,7 @@ export function AutomationDetail(props: {
                     type="button"
                     data-action="automation-open-source"
                     onClick={() => props.onOpenRun(sourceSessionID())}
-                    class="min-w-0 truncate text-right text-body text-fg-base hover:text-fg-strong hover:underline focus-visible:text-fg-strong focus-visible:underline focus:outline-none"
+                    class="inline-flex h-[30px] min-w-0 items-center truncate rounded-md px-2 text-right text-body text-fg-base hover:bg-row-hover-overlay hover:text-fg-strong focus-visible:bg-row-hover-overlay focus-visible:text-fg-strong focus:outline-none cursor-default"
                   >
                     {sessionLabel()}
                   </button>
diff --git a/packages/app/src/pages/automations/automation-folder-picker.tsx b/packages/app/src/pages/automations/automation-folder-picker.tsx
index 1b78ae96e..77229cc1c 100644
--- a/packages/app/src/pages/automations/automation-folder-picker.tsx
+++ b/packages/app/src/pages/automations/automation-folder-picker.tsx
@@ -1,7 +1,8 @@
-import { For, Show, type JSX } from "solid-js"
+import { createSignal, For, Show, type JSX } from "solid-js"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Popover } from "@opencode-ai/ui/popover"
 import { getFilename } from "@opencode-ai/util/path"
+import { useLanguage } from "@/context/language"
 import { workspaceKey } from "@/pages/layout/helpers"
 
 export interface AutomationProject {
@@ -22,9 +23,12 @@ export function AutomationFolderPicker(props: {
   projects: AutomationProject[]
   current: string
   onSelect: (project: AutomationProject) => void
+  onOpenProject?: () => void
   variant?: "knob" | "row"
   action?: string
 }): JSX.Element {
+  const language = useLanguage()
+  const [open, setOpen] = createSignal(false)
   const isActive = (project: AutomationProject) => workspaceKey(project.worktree) === workspaceKey(props.current)
   const label = () => {
     const match = props.projects.find(isActive)
@@ -35,6 +39,8 @@ export function AutomationFolderPicker(props: {
   return (
     <Popover
       modal
+      open={open()}
+      onOpenChange={setOpen}
       placement={row() ? "bottom-end" : "bottom-start"}
       class="min-w-56 max-w-xs"
       triggerAs="button"
@@ -42,44 +48,71 @@ export function AutomationFolderPicker(props: {
         {
           type: "button",
           "data-action": props.action ?? "automation-folder",
-          // data-picker-trigger carries picker.css's pill hover; the row
-          // variant instead matches the detail sidebar's underline hover so
-          // all editable rows read the same.
-          ...(row() ? {} : { "data-picker-trigger": "" }),
+          "data-picker-trigger": "",
+          "aria-label": language.t("workspace.chip.ariaLabel"),
           "aria-haspopup": "menu",
           class: row()
-            ? "flex min-w-0 items-center gap-1.5 truncate text-right text-body text-fg-base hover:text-fg-strong hover:underline focus-visible:text-fg-strong focus-visible:underline focus:outline-none cursor-default"
+            ? "inline-flex h-[30px] min-w-0 items-center gap-1.5 truncate rounded-md px-2 text-right text-body text-fg-base hover:bg-row-hover-overlay hover:text-fg-strong focus-visible:bg-row-hover-overlay focus-visible:text-fg-strong focus:outline-none cursor-default"
             : "inline-flex h-[30px] min-w-0 items-center gap-1.5 rounded-lg border border-border-weak px-2.5 text-body text-fg-base hover:bg-row-hover-overlay focus:outline-none cursor-default",
         } as never
       }
-      trigger={
-        <>
-          <Show when={!row()}>
-            <Icon name="folder" class="shrink-0 text-icon-weak" />
-          </Show>
-          <span class="min-w-0 truncate">{label()}</span>
-          <Icon name="chevron-down" class={row() ? "size-3 shrink-0 text-icon-weak" : "shrink-0 text-icon-weak"} />
-        </>
-      }
+      trigger={[
+        <Show when={!row()}>
+          <Icon name="folder" class="shrink-0 text-icon-weak" />
+        </Show>,
+        <span class="min-w-0 truncate">{label()}</span>,
+        <Icon name="chevron-down" class={row() ? "size-3 shrink-0 text-icon-weak" : "shrink-0 text-icon-weak"} />,
+      ]}
     >
-      <div role="menu" class="flex flex-col gap-px">
-        <For each={props.projects}>
-          {(project) => (
+      <div role="menu" aria-label={language.t("workspace.chip.popover.title")}>
+        <div class="px-2 pt-0.5 pb-2 text-body text-fg-weak">
+          {language.t("workspace.chip.popover.title")}
+        </div>
+        <Show
+          when={props.projects.length > 0}
+          fallback={<div class="px-2 py-2 text-body text-fg-weak">{language.t("workspace.chip.empty")}</div>}
+        >
+          <div class="flex flex-col gap-0.5">
+            <For each={props.projects}>
+              {(project) => (
+                <button
+                  type="button"
+                  role="menuitemradio"
+                  aria-checked={isActive(project)}
+                  data-picker-item=""
+                  data-project={project.id}
+                  data-selected={isActive(project) ? "true" : undefined}
+                  onClick={() => {
+                    props.onSelect(project)
+                    setOpen(false)
+                  }}
+                  class="flex w-full items-center text-left outline-none"
+                >
+                  <Icon name="folder" class="shrink-0 text-fg-weak" />
+                  <span class="min-w-0 flex-1 truncate">{projectLabel(project)}</span>
+                </button>
+              )}
+            </For>
+          </div>
+        </Show>
+        <Show when={props.onOpenProject}>
+          <div class="mt-1 border-t border-border-weaker pt-1">
             <button
               type="button"
-              role="menuitemradio"
-              aria-checked={isActive(project)}
+              role="menuitem"
+              data-action="automation-folder-open-project"
               data-picker-item=""
-              data-project={project.id}
-              data-selected={isActive(project) ? "" : undefined}
-              onClick={() => props.onSelect(project)}
               class="flex w-full items-center text-left outline-none"
+              onClick={() => {
+                setOpen(false)
+                props.onOpenProject?.()
+              }}
             >
-              <Icon name="folder" class="shrink-0 text-icon-weak" />
-              <span class="min-w-0 flex-1 truncate">{projectLabel(project)}</span>
+              <Icon name="folder-add-left" class="shrink-0 text-fg-weak" />
+              <span class="min-w-0 flex-1 truncate">{language.t("workspace.chip.add")}</span>
             </button>
-          )}
-        </For>
+          </div>
+        </Show>
       </div>
     </Popover>
   )
diff --git a/packages/app/src/pages/automations/automations-route.tsx b/packages/app/src/pages/automations/automations-route.tsx
index 15575cb41..437cf2c9f 100644
--- a/packages/app/src/pages/automations/automations-route.tsx
+++ b/packages/app/src/pages/automations/automations-route.tsx
@@ -18,6 +18,7 @@ export default function AutomationsRoute() {
       requestedID={requestedID}
       onClose={surface.close}
       onOpenRun={surface.automations.openRun}
+      onOpenProject={surface.automations.openProject}
       onCreateViaChat={surface.automations.createViaChat}
     />
   )
diff --git a/packages/app/src/pages/automations/automations-surface.tsx b/packages/app/src/pages/automations/automations-surface.tsx
index dcc4f2aad..d4f3e4043 100644
--- a/packages/app/src/pages/automations/automations-surface.tsx
+++ b/packages/app/src/pages/automations/automations-surface.tsx
@@ -68,6 +68,7 @@ export function AutomationsSurface(props: {
   requestedID?: Accessor<string | undefined>
   onClose: () => void
   onOpenRun: (sessionID: string) => void
+  onOpenProject: () => void
   onCreateViaChat: () => void
 }): JSX.Element {
   const globalSync = useGlobalSync()
@@ -219,6 +220,7 @@ export function AutomationsSurface(props: {
         directory={directory}
         projectID={projectID}
         template={template}
+        onOpenProject={props.onOpenProject}
         onCreated={(definition) => setSelectedID(definition.id)}
       />
     ))
@@ -299,6 +301,7 @@ export function AutomationsSurface(props: {
               projectName={() => item().projectName}
               onBack={() => setSelectedID(undefined)}
               onOpenRun={props.onOpenRun}
+              onOpenProject={props.onOpenProject}
               onMoved={(definition) => setSelectedID(definition.id)}
             />
           )}
diff --git a/packages/app/src/pages/layout.tsx b/packages/app/src/pages/layout.tsx
index 56878412b..4b3f5f2e3 100644
--- a/packages/app/src/pages/layout.tsx
+++ b/packages/app/src/pages/layout.tsx
@@ -809,15 +809,16 @@ export default function Layout(props: ParentProps) {
     layout.sidebar.toggleWorkspaces(project.worktree)
   }
 
-  async function chooseProject() {
+  async function chooseProject(options: { navigate?: boolean } = {}) {
+    const shouldNavigate = options.navigate ?? true
     function resolve(result: string | string[] | null) {
       if (Array.isArray(result)) {
         for (const directory of result) {
           openProject(directory, false)
         }
-        navigateToProject(result[0])
+        if (shouldNavigate) navigateToProject(result[0])
       } else if (result) {
-        openProject(result)
+        openProject(result, shouldNavigate)
       }
     }
 
@@ -1119,6 +1120,9 @@ export default function Layout(props: ParentProps) {
             openRun: (sessionID) => {
               void openAutomationRun(sessionID)
             },
+            openProject: () => {
+              void chooseProject({ navigate: false })
+            },
             createViaChat: createAutomationViaChat,
           },
           skills: {
diff --git a/packages/app/src/pages/layout/pawwork-routing-actions.test.ts b/packages/app/src/pages/layout/pawwork-routing-actions.test.ts
index 76d641dab..0fd31d393 100644
--- a/packages/app/src/pages/layout/pawwork-routing-actions.test.ts
+++ b/packages/app/src/pages/layout/pawwork-routing-actions.test.ts
@@ -73,6 +73,18 @@ describe("createPawworkRoutingActions", () => {
     })
   })
 
+  test("openProject can open a project without navigating away from the current surface", () => {
+    createRoot((dispose) => {
+      const { input, calls } = setup()
+      const actions = createPawworkRoutingActions(input)
+      actions.openProject("/repo", false)
+      expect(calls.projectsOpen).toEqual(["/repo"])
+      expect(calls.navigate).toEqual([])
+      expect(calls.touch).toEqual([])
+      dispose()
+    })
+  })
+
   test("syncSessionRoute returns root, marks viewed, expands the directory, and schedules the scroll via rAF", () => {
     const originalRAF = globalThis.requestAnimationFrame
     // Run the rAF callback synchronously so the scheduled scroll is observable;
diff --git a/packages/app/src/pages/layout/surface-page-context.tsx b/packages/app/src/pages/layout/surface-page-context.tsx
index bfe6e971d..4439dd2a1 100644
--- a/packages/app/src/pages/layout/surface-page-context.tsx
+++ b/packages/app/src/pages/layout/surface-page-context.tsx
@@ -15,6 +15,7 @@ export type SurfacePageContextValue = {
     directory: Accessor<string>
     projectID: Accessor<string | undefined>
     openRun: (sessionID: string) => void
+    openProject: () => void
     createViaChat: () => void
   }
   skills: {
diff --git a/packages/opencode/src/automation/index.ts b/packages/opencode/src/automation/index.ts
index 288f079b1..0e02947dc 100644
--- a/packages/opencode/src/automation/index.ts
+++ b/packages/opencode/src/automation/index.ts
@@ -4,8 +4,10 @@ import { InstanceState } from "@/effect/instance-state"
 import { makeRuntime } from "@/effect/run-service"
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
+import { GlobalBus } from "@/bus/global"
 import { Identifier } from "@/id/id"
 import { Instance } from "@/project/instance"
+import { Project } from "@/project/project"
 import { ProjectID } from "@/project/schema"
 import { PermissionID } from "@/permission/schema"
 import { ModelID, ProviderID } from "@/provider/schema"
@@ -155,6 +157,16 @@ export namespace Automation {
     .meta({ ref: "AutomationDefinition" })
   export type Definition = z.infer<typeof Definition>
 
+  export type Scope = {
+    projectID: ProjectID
+    ownerDirectory: string
+  }
+
+  export type ScopedDefinition = {
+    definition: Definition
+    scope: Scope
+  }
+
   export const Tombstone = z
     .object({ id: DefinitionID, deleted: z.literal(true), revision: z.number().int().positive() })
     .strict()
@@ -335,6 +347,18 @@ export namespace Automation {
     return { ...input, where: normalizeWhere(input.where) }
   }
 
+  export function currentScope(): Scope {
+    return { projectID: Instance.project.id, ownerDirectory: Instance.directory }
+  }
+
+  function rowScope(row: Pick<typeof AutomationDefinitionTable.$inferSelect, "project_id" | "owner_directory">): Scope {
+    return { projectID: row.project_id, ownerDirectory: row.owner_directory }
+  }
+
+  function scopeMatches(row: Pick<typeof AutomationDefinitionTable.$inferSelect, "project_id" | "owner_directory">, scope: Scope) {
+    return row.project_id === scope.projectID && row.owner_directory === scope.ownerDirectory
+  }
+
   export function getWriterKey(definition: Definition) {
     return definition.where.worktree ?? definition.where.projectID
   }
@@ -371,7 +395,17 @@ export namespace Automation {
     return details
   }
 
-  export function validateCreateInput(input: CreateInput | Definition, projectID = Instance.project.id, now?: number) {
+  export function validateCreateInput(
+    input: CreateInput | Definition,
+    options?: {
+      projectID?: ProjectID
+      now?: number
+      projectVcs?: Project.Info["vcs"]
+    },
+  ) {
+    const projectID = options?.projectID ?? Instance.project.id
+    const now = options?.now
+    const projectVcs = options?.projectVcs ?? Instance.project.vcs
     const details: ValidationErrorDetail[] = []
     const isDefinition = Object.hasOwn(input, "id")
     if (!isDefinition) {
@@ -394,7 +428,7 @@ export namespace Automation {
     if (input.where.worktree && input.context === "continue") {
       addDetail(details, "context", "unsupported_continue_with_worktree")
     }
-    if (input.where.worktree && Instance.project.vcs !== "git") {
+    if (input.where.worktree && projectVcs !== "git") {
       addDetail(details, "where.worktree", "unsupported_where_worktree_not_git")
     }
     if (input.kind === "recurring" && input.stop.kind === "condition") {
@@ -441,7 +475,7 @@ export namespace Automation {
   export function create(input: CreateInput, options?: { now?: number; sourceSessionID?: SessionID }): Definition {
     input = normalizeDefinitionInput(input)
     const now = options?.now ?? Date.now()
-    const details = validateCreateInput(input, Instance.project.id, now)
+    const details = validateCreateInput(input, { projectID: Instance.project.id, now })
     // A continue automation loops inside an existing conversation, so it must be
     // bound to one at creation. Only the automate tool can supply that source
     // (from its session context); the public HTTP create cannot, so reject a
@@ -495,17 +529,15 @@ export namespace Automation {
     return definition
   }
 
-  export function list(): Definition[] {
-    const projectID = Instance.project.id
-    const ownerDirectory = Instance.directory
+  export function list(scope: Scope = currentScope()): Definition[] {
     return Database.use((db) =>
       db
         .select()
         .from(AutomationDefinitionTable)
         .where(
           and(
-            eq(AutomationDefinitionTable.project_id, projectID),
-            eq(AutomationDefinitionTable.owner_directory, ownerDirectory),
+            eq(AutomationDefinitionTable.project_id, scope.projectID),
+            eq(AutomationDefinitionTable.owner_directory, scope.ownerDirectory),
           ),
         )
         .orderBy(desc(AutomationDefinitionTable.time_updated), desc(AutomationDefinitionTable.id))
@@ -514,14 +546,36 @@ export namespace Automation {
     )
   }
 
-  export function get(id: string): Definition {
-    const definition = getOptional(id)
+  export function listAll(): ScopedDefinition[] {
+    return Database.use((db) =>
+      db
+        .select()
+        .from(AutomationDefinitionTable)
+        .orderBy(desc(AutomationDefinitionTable.time_updated), desc(AutomationDefinitionTable.id))
+        .all()
+        .map((row) => ({ definition: Definition.parse(row.data), scope: rowScope(row) })),
+    )
+  }
+
+  export function get(id: string, scope: Scope = currentScope()): Definition {
+    const definition = getOptional(id, scope)
     if (!definition) throw new NotFoundError({ message: `Automation not found: ${id}` })
     return definition
   }
 
-  function getOptional(id: string): Definition | undefined {
-    const projectID = Instance.project.id
+  export function getScope(id: string): Scope {
+    const row = Database.use((db) =>
+      db
+        .select()
+        .from(AutomationDefinitionTable)
+        .where(eq(AutomationDefinitionTable.id, id))
+        .get(),
+    )
+    if (!row) throw new NotFoundError({ message: `Automation not found: ${id}` })
+    return rowScope(row)
+  }
+
+  function getOptional(id: string, scope: Scope = currentScope()): Definition | undefined {
     const row = Database.use((db) =>
       db
         .select()
@@ -529,8 +583,7 @@ export namespace Automation {
         .where(eq(AutomationDefinitionTable.id, id))
         .get(),
     )
-    if (!row || row.project_id !== projectID) return undefined
-    if (row.owner_directory !== Instance.directory) return undefined
+    if (!row || !scopeMatches(row, scope)) return undefined
     return Definition.parse(row.data)
   }
 
@@ -550,11 +603,12 @@ export namespace Automation {
     )
   }
 
-  function replaceDefinition(previous: Definition, next: Definition) {
+  function replaceDefinition(previous: Definition, next: Definition, options?: { expectedScope?: Scope; moveToOwnerDirectory?: string }) {
+    const expectedOwnerDirectory = options?.expectedScope?.ownerDirectory ?? Instance.directory
     return Database.transaction(
       (db) => {
         const row = db.select().from(AutomationDefinitionTable).where(eq(AutomationDefinitionTable.id, previous.id)).get()
-        if (!row || row.project_id !== previous.where.projectID || row.owner_directory !== Instance.directory) {
+        if (!row || row.project_id !== previous.where.projectID || row.owner_directory !== expectedOwnerDirectory) {
           throw new NotFoundError({ message: `Automation not found: ${previous.id}` })
         }
         const current = Definition.parse(row.data)
@@ -562,7 +616,7 @@ export namespace Automation {
         db.update(AutomationDefinitionTable)
           .set({
             project_id: next.where.projectID,
-            owner_directory: Instance.directory,
+            owner_directory: options?.moveToOwnerDirectory ?? expectedOwnerDirectory,
             time_updated: next.updatedAt,
             data: next,
           })
@@ -579,8 +633,8 @@ export namespace Automation {
     )
   }
 
-  function writeRun(run: Run) {
-    const definition = getOptional(run.automationID)
+  function writeRun(run: Run, scope: Scope = currentScope()) {
+    const definition = getOptional(run.automationID, scope)
     if (!definition) throw new NotFoundError({ message: `Automation not found: ${run.automationID}` })
     const now = Date.now()
     Database.use((db) =>
@@ -590,7 +644,7 @@ export namespace Automation {
           id: run.id,
           automation_id: run.automationID,
           project_id: definition.where.projectID,
-          owner_directory: Instance.directory,
+          owner_directory: scope.ownerDirectory,
           triggered_at: run.triggeredAt,
           data: run,
           time_created: now,
@@ -609,6 +663,13 @@ export namespace Automation {
     return Run.parse(row.data)
   }
 
+  function getRunAnyScope(runID: string): Run | undefined {
+    const row = Database.use((db) =>
+      db.select().from(AutomationRunTable).where(eq(AutomationRunTable.id, runID)).get(),
+    )
+    return row ? Run.parse(row.data) : undefined
+  }
+
   function isSameValue(left: unknown, right: unknown): boolean {
     if (Object.is(left, right)) return true
     if (Array.isArray(left) || Array.isArray(right)) {
@@ -636,6 +697,14 @@ export namespace Automation {
     patch = normalizeUpdateInput(patch)
     const now = options?.now ?? Date.now()
     const updateDetails = validateUpdateInput(previous, patch, now)
+    const targetProjectID = patch.where?.projectID
+    const isMove = targetProjectID !== undefined && targetProjectID !== previous.where.projectID
+    const targetProject = isMove ? Project.get(targetProjectID) : undefined
+    if (isMove) {
+      if (previous.context === "continue") addDetail(updateDetails, "where.projectID", "unsupported_continue_move")
+      if (hasActiveRun(previous.id)) addDetail(updateDetails, "where.projectID", "unsupported_move_with_active_run")
+      if (!targetProject) addDetail(updateDetails, "where.projectID", "project_not_found")
+    }
     if (updateDetails.length) throw new ValidationError(updateDetails)
     if (!hasChanges(previous, patch)) return previous
     const merged: Record<string, unknown> = { ...previous, ...patch }
@@ -645,8 +714,6 @@ export namespace Automation {
       revision: previous.revision + 1,
       updatedAt: now,
     })
-    const details = validateCreateInput(next)
-    if (details.length) throw new ValidationError(details)
     if (next.kind === "recurring" && previous.kind === "recurring") {
       const scheduleChanged =
         !isSameValue(previous.rhythm, next.rhythm) ||
@@ -658,7 +725,11 @@ export namespace Automation {
         next = { ...next, nextFireAt: derived.nextFireAt, nextFires: derived.nextFires }
       }
     }
-    return replaceDefinition(previous, next)
+    const createProjectID = targetProject?.id ?? Instance.project.id
+    const createProjectVcs = targetProject?.vcs ?? Instance.project.vcs
+    const details = validateCreateInput(next, { projectID: createProjectID, projectVcs: createProjectVcs })
+    if (details.length) throw new ValidationError(details)
+    return replaceDefinition(previous, next, targetProject ? { moveToOwnerDirectory: targetProject.worktree } : undefined)
   }
 
   export function recordRunOutcome(
@@ -666,24 +737,35 @@ export namespace Automation {
     options?: {
       now?: number
       refreshOnStopped?: boolean
+      scope?: Scope
     },
   ): Definition | undefined {
     if (run.state !== "succeeded" && run.state !== "failed" && run.state !== "stopped") return undefined
     const now = options?.now ?? Date.now()
+    let scope = options?.scope ?? currentScope()
     // Retry on revision conflict: a concurrent write (e.g. pause/update) may
     // have advanced the row between our read and our update. Re-read the
     // latest definition and recompute failureStreak + derived fields against
     // it, otherwise we silently drop the run's outcome and the user sees a
     // stale nextFireAt / failureStreak.
     for (let attempt = 0; attempt < 3; attempt++) {
-      const previous = getOptional(run.automationID)
+      let previous = getOptional(run.automationID, scope)
+      if (!previous) {
+        try {
+          scope = getScope(run.automationID)
+          previous = getOptional(run.automationID, scope)
+        } catch (error) {
+          if (NotFoundError.isInstance(error)) return undefined
+          throw error
+        }
+      }
       if (!previous || previous.kind !== "recurring") return undefined
       const failureStreak =
         run.state === "succeeded" ? 0 : run.state === "failed" ? previous.failureStreak + 1 : previous.failureStreak
       const derived =
         run.state === "stopped" && !options?.refreshOnStopped
           ? { nextFireAt: previous.nextFireAt, nextFires: previous.nextFires }
-          : computeDerivedFields(previous, now, completedRunCount(previous.id))
+          : computeDerivedFields(previous, now, completedRunCount(previous.id, scope))
       if (
         previous.failureStreak === failureStreak &&
         previous.nextFireAt === derived.nextFireAt &&
@@ -701,7 +783,7 @@ export namespace Automation {
       })
       internalTestHooks.beforeReplaceDefinition?.(previous)
       try {
-        return replaceDefinition(previous, next)
+        return replaceDefinition(previous, next, { expectedScope: scope })
       } catch (error) {
         if (!(error instanceof ConflictError)) throw error
         // retry: read latest and recompute
@@ -747,11 +829,11 @@ export namespace Automation {
     }
   }
 
-  function replaceRun(previous: Run, next: Run) {
+  function replaceRun(previous: Run, next: Run, scope: Scope = currentScope()) {
     return Database.transaction(
       (db) => {
         const row = db.select().from(AutomationRunTable).where(eq(AutomationRunTable.id, previous.id)).get()
-        if (!row || row.project_id !== Instance.project.id || row.owner_directory !== Instance.directory) return previous
+        if (!row || row.project_id !== scope.projectID || row.owner_directory !== scope.ownerDirectory) return previous
         const current = Run.parse(row.data)
         if (current.revision !== previous.revision) return current
         const now = Date.now()
@@ -777,7 +859,7 @@ export namespace Automation {
     )
   }
 
-  function reviseRun(run: Run, patch: Record<string, unknown>): Run {
+  function reviseRun(run: Run, patch: Record<string, unknown>, scope?: Scope): Run {
     const next = {
       ...run,
       ...patch,
@@ -788,22 +870,26 @@ export namespace Automation {
     for (const [key, value] of Object.entries(next)) {
       if (value === undefined) delete (next as Record<string, unknown>)[key]
     }
-    return replaceRun(run, Run.parse(next))
+    return replaceRun(run, Run.parse(next), scope)
   }
 
   function stopRun(
     run: Run,
     stopReason: Extract<Run, { state: "stopped" }>["stopReason"],
-    options?: { now?: number },
+    options?: { now?: number; scope?: Scope },
   ): Run {
     if (run.state === "stopped" || run.state === "succeeded" || run.state === "failed") return run
-    return reviseRun(run, {
-      state: "stopped",
-      completedAt: options?.now ?? Date.now(),
-      result: null,
-      error: null,
-      stopReason,
-    })
+    return reviseRun(
+      run,
+      {
+        state: "stopped",
+        completedAt: options?.now ?? Date.now(),
+        result: null,
+        error: null,
+        stopReason,
+      },
+      options?.scope,
+    )
   }
 
   function stopActiveRun(automationID: string) {
@@ -879,8 +965,9 @@ export namespace Automation {
     })
   }
 
-  export function runNow(id: string, options?: { now?: number; runID?: string }): Run {
-    const definition = get(id)
+  export function runNow(id: string, options?: { now?: number; runID?: string; scope?: Scope }): Run {
+    const scope = options?.scope ?? currentScope()
+    const definition = get(id, scope)
     const run = Run.parse({
       id: options?.runID ?? AutomationID.Run.ascending(),
       automationID: id,
@@ -895,15 +982,13 @@ export namespace Automation {
       error: null,
       cost: null,
     })
-    writeRun(run)
+    writeRun(run, scope)
     return run
   }
 
   export function hasActiveRun(automationID: string): boolean {
     if (state().activeRuns.has(automationID)) return true
     get(automationID)
-    const projectID = Instance.project.id
-    const ownerDirectory = Instance.directory
     return Boolean(
       Database.use((db) =>
         db
@@ -912,8 +997,6 @@ export namespace Automation {
           .where(
             and(
               eq(AutomationRunTable.automation_id, automationID),
-              eq(AutomationRunTable.project_id, projectID),
-              eq(AutomationRunTable.owner_directory, ownerDirectory),
               sql`json_extract(${AutomationRunTable.data}, '$.state') in ('scheduled', 'running', 'awaiting_input')`,
             ),
           )
@@ -927,12 +1010,12 @@ export namespace Automation {
     return run.state === "scheduled" || run.state === "running" || run.state === "awaiting_input"
   }
 
-  function runLeaseKey(runID: string) {
-    return `automation-run:${Instance.directory}:${runID}`
+  function runLeaseKey(ownerDirectory: string, runID: string) {
+    return `automation-run:${ownerDirectory}:${runID}`
   }
 
-  async function hasLiveRunLease(runID: string) {
-    const lease = await Flock.tryAcquire(runLeaseKey(runID))
+  async function hasLiveRunLease(runID: string, ownerDirectory = Instance.directory) {
+    const lease = await Flock.tryAcquire(runLeaseKey(ownerDirectory, runID))
     if (!lease) return true
     await lease.release().catch(() => undefined)
     return false
@@ -986,10 +1069,12 @@ export namespace Automation {
     )
   }
 
-  export function hasRunTriggeredAtOrAfter(automationID: string, triggeredAt: number): boolean {
-    get(automationID)
-    const projectID = Instance.project.id
-    const ownerDirectory = Instance.directory
+  export function hasRunTriggeredAtOrAfter(
+    automationID: string,
+    triggeredAt: number,
+    scope: Scope = currentScope(),
+  ): boolean {
+    get(automationID, scope)
     return Boolean(
       Database.use((db) =>
         db
@@ -998,8 +1083,6 @@ export namespace Automation {
           .where(
             and(
               eq(AutomationRunTable.automation_id, automationID),
-              eq(AutomationRunTable.project_id, projectID),
-              eq(AutomationRunTable.owner_directory, ownerDirectory),
               gte(AutomationRunTable.triggered_at, triggeredAt),
             ),
           )
@@ -1009,10 +1092,8 @@ export namespace Automation {
     )
   }
 
-  export function completedRunCount(automationID: string): number {
-    get(automationID)
-    const projectID = Instance.project.id
-    const ownerDirectory = Instance.directory
+  export function completedRunCount(automationID: string, scope: Scope = currentScope()): number {
+    get(automationID, scope)
     const row = Database.use((db) =>
       db
         .select({ count: sql<number>`count(*)` })
@@ -1020,8 +1101,6 @@ export namespace Automation {
         .where(
           and(
             eq(AutomationRunTable.automation_id, automationID),
-            eq(AutomationRunTable.project_id, projectID),
-            eq(AutomationRunTable.owner_directory, ownerDirectory),
             sql`json_extract(${AutomationRunTable.data}, '$.state') in ('succeeded', 'failed')`,
           ),
         )
@@ -1030,9 +1109,10 @@ export namespace Automation {
     return Number(row?.count ?? 0)
   }
 
-  export async function reconcileInterruptedRuns(options?: { now?: number }): Promise<Run[]> {
-    const projectID = Instance.project.id
-    const ownerDirectory = Instance.directory
+  export async function reconcileInterruptedRuns(options?: { now?: number; scope?: Scope }): Promise<Run[]> {
+    const scope = options?.scope ?? currentScope()
+    const projectID = scope.projectID
+    const ownerDirectory = scope.ownerDirectory
     const now = options?.now ?? Date.now()
     const rows = Database.use((db) =>
       db
@@ -1051,9 +1131,9 @@ export namespace Automation {
     for (const row of rows) {
       const run = Run.parse(row.data)
       if (!isActiveRun(run)) continue
-      const active = state().activeRuns.get(run.automationID)
+      const active = options?.scope ? undefined : state().activeRuns.get(run.automationID)
       if (active?.runID === run.id) continue
-      if (await hasLiveRunLease(run.id)) continue
+      if (await hasLiveRunLease(run.id, ownerDirectory)) continue
       const next = Database.transaction(
         (db) => {
           const currentRow = db.select().from(AutomationRunTable).where(eq(AutomationRunTable.id, run.id)).get()
@@ -1087,9 +1167,9 @@ export namespace Automation {
   export function recordStoppedRun(
     automationID: string,
     stopReason: Extract<Run, { state: "stopped" }>["stopReason"],
-    options?: { now?: number; triggeredAt?: number },
+    options?: { now?: number; triggeredAt?: number; scope?: Scope },
   ): Run {
-    const run = runNow(automationID, { now: options?.triggeredAt ?? options?.now })
+    const run = runNow(automationID, { now: options?.triggeredAt ?? options?.now, scope: options?.scope })
     return stopRun(run, stopReason, options)
   }
 
@@ -1098,7 +1178,7 @@ export namespace Automation {
     options: { executor: RunExecutor; attendance?: AutomationRunAttendance; now?: number },
   ): Promise<Run> {
     const runID = AutomationID.Run.ascending()
-    const lease = await Flock.acquire(runLeaseKey(runID))
+    const lease = await Flock.acquire(runLeaseKey(Instance.directory, runID))
     try {
       const initial = runNow(id, { now: options.now, runID })
       queueMicrotask(() => void executeRun(initial, options.executor, options.attendance ?? "attended", lease))
@@ -1191,9 +1271,7 @@ export namespace Automation {
   export function runs(input: { automationID: string; limit?: number; cursor?: string }) {
     const limit = Math.min(Math.max(input.limit ?? 50, 1), 100)
     get(input.automationID)
-    const projectID = Instance.project.id
-    const ownerDirectory = Instance.directory
-    const cursorRun = input.cursor ? getRun(input.cursor) : undefined
+    const cursorRun = input.cursor ? getRunAnyScope(input.cursor) : undefined
     if (input.cursor && (!cursorRun || cursorRun.automationID !== input.automationID)) return { items: [], nextCursor: null }
     const cursorPredicate = cursorRun
       ? or(
@@ -1208,8 +1286,6 @@ export namespace Automation {
         .where(
           and(
             eq(AutomationRunTable.automation_id, input.automationID),
-            eq(AutomationRunTable.project_id, projectID),
-            eq(AutomationRunTable.owner_directory, ownerDirectory),
             cursorPredicate,
           ),
         )
@@ -1223,7 +1299,21 @@ export namespace Automation {
   }
 
   export const publishDefinitionUpdated = (definition: Definition) => Bus.publish(Event.DefinitionUpdated, definition)
+  export const publishDefinitionUpdatedForScope = (definition: Definition, scope: Scope) => {
+    GlobalBus.emit("event", {
+      directory: scope.ownerDirectory,
+      project: scope.projectID,
+      payload: { type: Event.DefinitionUpdated.type, properties: definition },
+    })
+  }
   export const publishRunUpdated = (run: Run) => Bus.publish(Event.RunUpdated, run)
+  export const publishRunUpdatedForScope = (run: Run, scope: Scope) => {
+    GlobalBus.emit("event", {
+      directory: scope.ownerDirectory,
+      project: scope.projectID,
+      payload: { type: Event.RunUpdated.type, properties: run },
+    })
+  }
 
   export interface Interface {
     readonly list: () => Effect.Effect<Definition[]>
@@ -1250,6 +1340,7 @@ export namespace Automation {
       cursor?: string
     }) => Effect.Effect<z.infer<typeof RunsResponse>>
     readonly publishDefinitionUpdated: (definition: Definition) => Effect.Effect<void>
+    readonly publishDefinitionUpdatedForScope: (definition: Definition, scope: Scope) => Effect.Effect<void>
     readonly publishDefinitionDeleted: (tombstone: Tombstone) => Effect.Effect<void>
     readonly publishRunUpdated: (run: Run) => Effect.Effect<void>
     // Execution-face: the per-directory mutable active-run/writer state, owned by InstanceState.
@@ -1292,6 +1383,7 @@ export namespace Automation {
         runNowExecuting: (id, options) => Effect.promise(() => runNowExecuting(id, options)),
         runs: (input) => Effect.sync(() => runs(input)),
         publishDefinitionUpdated: (definition) => Effect.promise(() => publishDefinitionUpdated(definition)),
+        publishDefinitionUpdatedForScope: (definition, scope) => Effect.sync(() => publishDefinitionUpdatedForScope(definition, scope)),
         publishDefinitionDeleted: (tombstone) => Effect.promise(() => Bus.publish(Event.DefinitionDeleted, tombstone)),
         publishRunUpdated: (run) => Effect.promise(() => publishRunUpdated(run)),
         activeState: () => InstanceState.get(activeStateHandle),
diff --git a/packages/opencode/src/automation/scheduler.ts b/packages/opencode/src/automation/scheduler.ts
index 5de4c6ebf..e04f7e07d 100644
--- a/packages/opencode/src/automation/scheduler.ts
+++ b/packages/opencode/src/automation/scheduler.ts
@@ -2,8 +2,9 @@ import { Context, Effect, Fiber, Layer } from "effect"
 import { DateTime } from "luxon"
 import { Log } from "@opencode-ai/core/util/log"
 import { Automation } from "."
-import { Bus } from "@/bus"
-import { Instance, type InstanceContext } from "@/project/instance"
+import { GlobalBus } from "@/bus/global"
+import { Instance } from "@/project/instance"
+import { ProjectID } from "@/project/schema"
 import { Session } from "@/session"
 import { NotFoundError } from "@/storage/db"
 import { Flock } from "@/util/flock"
@@ -30,12 +31,11 @@ export namespace AutomationScheduler {
   }
 
   export interface Interface {
-    stop(): void
-    stopOwnedRuns(): void
+    stop(options?: { stopRuns?: boolean }): void
     settleOwner(): Promise<void>
-    reschedule(definition: Automation.Definition): void
+    reschedule(definition: Automation.Definition, scope?: Automation.Scope): void
     cancel(automationID: string): void
-    computeNextFireAt(definition: Automation.Definition, from?: number): number | null
+    computeNextFireAt(definition: Automation.Definition, from?: number, scope?: Automation.Scope): number | null
   }
 
   export interface Options {
@@ -52,6 +52,21 @@ export namespace AutomationScheduler {
     fireAt: number
     token: symbol
     definition: Automation.Definition
+    scope: Automation.Scope
+  }
+
+  type OwnedRun = {
+    automationID: string
+    scope: Automation.Scope
+  }
+
+  type GlobalEventEnvelope = {
+    directory?: string
+    project?: string
+    payload?: {
+      type?: string
+      properties?: unknown
+    }
   }
 
   export const liveClock: Clock = {
@@ -101,13 +116,17 @@ export namespace AutomationScheduler {
     )
   export const defaultLayer = layer()
 
-  export function computeNextFireAt(definition: Automation.Definition, from: number): number | null {
+  export function computeNextFireAt(
+    definition: Automation.Definition,
+    from: number,
+    scope: Automation.Scope = Automation.currentScope(),
+  ): number | null {
     if (definition.paused) return null
     if (definition.kind === "oneshot") {
-      if (Automation.hasRunTriggeredAtOrAfter(definition.id, definition.fireAt)) return null
+      if (Automation.hasRunTriggeredAtOrAfter(definition.id, definition.fireAt, scope)) return null
       return definition.fireAt
     }
-    if (!canScheduleRecurring(definition)) return null
+    if (!canScheduleRecurring(definition, scope)) return null
     if (definition.rhythm.kind === "cron") return computeNextCronFireAt(definition, from)
     return from + definition.rhythm.everyMs
   }
@@ -134,9 +153,12 @@ export namespace AutomationScheduler {
     return null
   }
 
-  function canScheduleRecurring(definition: Extract<Automation.Definition, { kind: "recurring" }>) {
+  function canScheduleRecurring(
+    definition: Extract<Automation.Definition, { kind: "recurring" }>,
+    scope: Automation.Scope = Automation.currentScope(),
+  ) {
     if (definition.stop.kind === "never") return true
-    if (definition.stop.kind === "count") return Automation.completedRunCount(definition.id) < definition.stop.count
+    if (definition.stop.kind === "count") return Automation.completedRunCount(definition.id, scope) < definition.stop.count
     return false
   }
 
@@ -153,6 +175,29 @@ export namespace AutomationScheduler {
     return false
   }
 
+  function scopeKey(scope: Automation.Scope) {
+    return `${scope.projectID}\n${scope.ownerDirectory}`
+  }
+
+  function sameScope(left: Automation.Scope, right: Automation.Scope) {
+    return left.projectID === right.projectID && left.ownerDirectory === right.ownerDirectory
+  }
+
+  function scopeFromEvent(event: GlobalEventEnvelope): Automation.Scope | undefined {
+    if (!event.directory || !event.project) return undefined
+    return {
+      projectID: ProjectID.zod.parse(event.project),
+      ownerDirectory: event.directory,
+    }
+  }
+
+  async function runInScope<T>(scope: Automation.Scope, fn: () => T | Promise<T>): Promise<T> {
+    return Instance.provide({
+      directory: scope.ownerDirectory,
+      fn,
+    })
+  }
+
   export function make(options: Options = {}): Interface {
     const clock = options.clock ?? liveClock
     const executor = options.executor ?? sessionPromptExecutor
@@ -162,7 +207,7 @@ export namespace AutomationScheduler {
     const ownerRescanMs = options.ownerRescanMs ?? 5_000
     const tasks = new Map<string, ScheduledTask>()
     const unschedulable = new Map<string, Automation.Definition>()
-    const ownedRuns = new Map<string, string>()
+    const ownedRuns = new Map<string, OwnedRun>()
     const schedulerStoppedRuns = new Set<string>()
     // Marks DefinitionUpdated events that the scheduler emits itself after a
     // stopped-run refresh, so its own DefinitionUpdated subscriber can skip
@@ -172,6 +217,7 @@ export namespace AutomationScheduler {
     const selfPublishedDefinitionUpdates = new Set<string>()
     const selfUpdateKey = (definition: { id: string; revision: number }) =>
       `${definition.id}:${definition.revision}`
+    const selfPublishedRunUpdates = new Set<string>()
     let ownsTimers = !ownerKey
     let ownerLease: Flock.Lease | undefined
     let ownerAttempt: Promise<void> | undefined
@@ -187,14 +233,14 @@ export namespace AutomationScheduler {
       entry.task.interrupt()
     }
 
-    const scheduleNextInterval = (automationID: string) => {
+    const scheduleNextInterval = (automationID: string, scope: Automation.Scope = Automation.currentScope()) => {
       try {
-        const latest = Automation.get(automationID)
-        if (latest.kind === "recurring" && !latest.paused && canScheduleRecurring(latest)) {
+        const latest = Automation.get(automationID, scope)
+        if (latest.kind === "recurring" && !latest.paused && canScheduleRecurring(latest, scope)) {
           const next =
-            latest.rhythm.kind === "interval" ? clock.now() + latest.rhythm.everyMs : computeNextFireAt(latest, clock.now())
+            latest.rhythm.kind === "interval" ? clock.now() + latest.rhythm.everyMs : computeNextFireAt(latest, clock.now(), scope)
           if (next === null) cancel(automationID)
-          else schedule(latest, next)
+          else schedule(latest, next, scope)
         } else {
           cancel(automationID)
         }
@@ -204,47 +250,101 @@ export namespace AutomationScheduler {
       }
     }
 
-    const fire = async (automationID: string, triggeredAt: number) => {
-      tasks.delete(automationID)
-      const firedAt = clock.now()
+    const publishScopedRunUpdated = (run: Automation.Run, scope: Automation.Scope) => {
+      selfPublishedRunUpdates.add(run.id)
+      Automation.publishRunUpdatedForScope(run, scope)
+    }
+
+    const currentDefinitionScope = (automationID: string, fallback: Automation.Scope) => {
       try {
-        const latest = Automation.get(automationID)
-        if (latest.paused) return
-        if (latest.kind === "oneshot" && latest.fireAt !== triggeredAt) return
-        if (latest.kind === "recurring" && !canScheduleRecurring(latest)) return
-        if (firedAt - triggeredAt > MISSED_SCHEDULE_GRACE_MS) {
-          const stopped = Automation.recordStoppedRun(automationID, "missed_schedule", { now: firedAt, triggeredAt })
-          schedulerStoppedRuns.add(stopped.id)
-          void Automation.publishRunUpdated(stopped)
-          if (latest.kind === "recurring") scheduleNextInterval(automationID)
-          return
-        }
+        return Automation.getScope(automationID)
       } catch (error) {
-        if (!NotFoundError.isInstance(error)) throw error
-        return
-      }
-      for (const run of await Automation.reconcileInterruptedRuns({ now: firedAt })) void Automation.publishRunUpdated(run)
-      if (Automation.hasActiveRun(automationID)) {
-        const stopped = Automation.recordStoppedRun(automationID, "previous_run_awaiting_input", { now: triggeredAt })
-        schedulerStoppedRuns.add(stopped.id)
-        void Automation.publishRunUpdated(stopped)
-        scheduleNextInterval(automationID)
-        return
+        if (NotFoundError.isInstance(error)) return fallback
+        throw error
       }
+    }
+
+    const refreshScopedRunOutcome = (
+      run: Automation.Run,
+      scope: Automation.Scope,
+      options?: { refreshOnStopped?: boolean },
+    ) => {
+      if (!ownsTimers) return scope
       try {
-        const run = await Automation.runNowExecuting(automationID, {
-          executor,
-          attendance: "unattended",
-          now: triggeredAt,
+        const refreshed = Automation.recordRunOutcome(run, {
+          now: clock.now(),
+          refreshOnStopped: options?.refreshOnStopped ?? true,
+          scope,
         })
-        ownedRuns.set(run.id, automationID)
-        const latest = Automation.get(automationID)
-        if (latest.kind === "recurring" && latest.rhythm.kind === "cron") scheduleNextInterval(automationID)
+        if (!refreshed) return currentDefinitionScope(run.automationID, scope)
+        const refreshedScope = currentDefinitionScope(refreshed.id, scope)
+        selfPublishedDefinitionUpdates.add(selfUpdateKey(refreshed))
+        Automation.publishDefinitionUpdatedForScope(refreshed, refreshedScope)
+        return refreshedScope
       } catch (error) {
-        if (!NotFoundError.isInstance(error)) throw error
+        if (!NotFoundError.isInstance(error)) log.error("automation derived field update failed", { error, automationID: run.automationID })
+        return scope
       }
     }
 
+    const publishScopedStoppedRun = (run: Automation.Run, scope: Automation.Scope, options?: { scheduleNext?: boolean }) => {
+      const refreshedScope = refreshScopedRunOutcome(run, scope)
+      publishScopedRunUpdated(run, scope)
+      if (options?.scheduleNext) scheduleNextInterval(run.automationID, refreshedScope)
+    }
+
+    const fire = async (automationID: string, triggeredAt: number) => {
+      const entry = tasks.get(automationID)
+      if (!entry) return
+      tasks.delete(automationID)
+      await runInScope(entry.scope, async () => {
+        const firedAt = clock.now()
+        try {
+          const latest = Automation.get(automationID)
+          if (latest.paused) return
+          if (latest.kind === "oneshot" && latest.fireAt !== triggeredAt) return
+          if (latest.kind === "recurring" && !canScheduleRecurring(latest, entry.scope)) return
+          if (firedAt - triggeredAt > MISSED_SCHEDULE_GRACE_MS) {
+            const stopped = Automation.recordStoppedRun(automationID, "missed_schedule", {
+              now: firedAt,
+              triggeredAt,
+              scope: entry.scope,
+            })
+            schedulerStoppedRuns.add(stopped.id)
+            void Automation.publishRunUpdated(stopped)
+            if (latest.kind === "recurring") scheduleNextInterval(automationID, entry.scope)
+            return
+          }
+        } catch (error) {
+          if (!NotFoundError.isInstance(error)) throw error
+          return
+        }
+        for (const run of await Automation.reconcileInterruptedRuns({ now: firedAt })) void Automation.publishRunUpdated(run)
+        if (Automation.hasActiveRun(automationID)) {
+          const stopped = Automation.recordStoppedRun(automationID, "previous_run_awaiting_input", {
+            now: triggeredAt,
+            scope: entry.scope,
+          })
+          schedulerStoppedRuns.add(stopped.id)
+          void Automation.publishRunUpdated(stopped)
+          scheduleNextInterval(automationID, entry.scope)
+          return
+        }
+        try {
+          const run = await Automation.runNowExecuting(automationID, {
+            executor,
+            attendance: "unattended",
+            now: triggeredAt,
+          })
+          ownedRuns.set(run.id, { automationID, scope: Automation.currentScope() })
+          const latest = Automation.get(automationID)
+          if (latest.kind === "recurring" && latest.rhythm.kind === "cron") scheduleNextInterval(automationID, entry.scope)
+        } catch (error) {
+          if (!NotFoundError.isInstance(error)) throw error
+        }
+      })
+    }
+
     const isCurrentTask = (automationID: string, fireAt: number, token: symbol, signal: AbortSignal) => {
       const current = tasks.get(automationID)
       return !signal.aborted && running && current?.token === token && current.fireAt === fireAt
@@ -261,7 +361,7 @@ export namespace AutomationScheduler {
         yield* Effect.promise(() => fire(automationID, fireAt))
       })
 
-    const schedule = (definition: Automation.Definition, fireAt: number) => {
+    const schedule = (definition: Automation.Definition, fireAt: number, scope: Automation.Scope) => {
       cancel(definition.id)
       if (!running || !ownsTimers || definition.paused) return
       const token = Symbol(definition.id)
@@ -270,20 +370,23 @@ export namespace AutomationScheduler {
         fireAt,
         token,
         definition,
+        scope,
       })
     }
 
-    const preservePendingSchedule = (definition: Automation.Definition) => {
+    const preservePendingSchedule = (definition: Automation.Definition, scope: Automation.Scope) => {
       const current = tasks.get(definition.id)
       if (!current || current.fireAt <= clock.now() || !isSameSchedule(current.definition, definition)) return false
       current.definition = definition
+      current.scope = scope
       return true
     }
 
-    const preserveDueSchedule = (definition: Automation.Definition) => {
+    const preserveDueSchedule = (definition: Automation.Definition, scope: Automation.Scope) => {
       const current = tasks.get(definition.id)
       if (!current || current.fireAt > clock.now() || !isSameSchedule(current.definition, definition)) return false
       current.definition = definition
+      current.scope = scope
       return true
     }
 
@@ -291,108 +394,170 @@ export namespace AutomationScheduler {
       definition.kind === "recurring" && definition.rhythm.kind === "cron" && definition.stop.kind === "never"
 
     const hasSchedulerOwnedActiveRun = (automationID: string) => {
-      for (const ownedAutomationID of ownedRuns.values()) {
-        if (ownedAutomationID === automationID) return true
+      for (const owned of ownedRuns.values()) {
+        if (owned.automationID === automationID) return true
       }
       return false
     }
 
-    const reschedule = (definition: Automation.Definition) => {
+    const reschedule = (definition: Automation.Definition, scope = Automation.currentScope()) => {
       if (!ownsTimers) return
-      if (preserveDueSchedule(definition)) return
-      if (isStableCronSchedule(definition) && preservePendingSchedule(definition)) return
+      if (preserveDueSchedule(definition, scope)) return
+      if (isStableCronSchedule(definition) && preservePendingSchedule(definition, scope)) return
       const cached = unschedulable.get(definition.id)
       if (cached && isSameSchedule(cached, definition)) return
       unschedulable.delete(definition.id)
-      if (definition.kind === "recurring" && definition.rhythm.kind === "cron" && canScheduleRecurring(definition)) {
+      if (definition.kind === "recurring" && definition.rhythm.kind === "cron" && canScheduleRecurring(definition, scope)) {
         const firstScheduled = computeNextCronFireAt(definition, definition.createdAt)
         const missed = firstScheduled === null ? null : computePreviousCronFireAt(definition, firstScheduled, clock.now())
-        if (missed !== null && !Automation.hasRunTriggeredAtOrAfter(definition.id, missed)) {
-          const stopped = Automation.recordStoppedRun(definition.id, "missed_schedule", { now: clock.now(), triggeredAt: missed })
-          schedulerStoppedRuns.add(stopped.id)
-          void Automation.publishRunUpdated(stopped)
+        if (missed !== null && !Automation.hasRunTriggeredAtOrAfter(definition.id, missed, scope)) {
+          const stopped = Automation.recordStoppedRun(definition.id, "missed_schedule", {
+            now: clock.now(),
+            triggeredAt: missed,
+            scope,
+          })
+          publishScopedStoppedRun(stopped, scope)
         }
       }
-      const next = computeNextFireAt(definition, clock.now())
+      const next = computeNextFireAt(definition, clock.now(), scope)
       if (next === null) {
         cancel(definition.id)
         if (isStableCronSchedule(definition)) unschedulable.set(definition.id, definition)
         return
       }
       if (definition.kind === "oneshot" && next <= clock.now()) {
-        const stopped = Automation.recordStoppedRun(definition.id, "missed_schedule", { now: clock.now(), triggeredAt: next })
-        schedulerStoppedRuns.add(stopped.id)
-        void Automation.publishRunUpdated(stopped)
+        const stopped = Automation.recordStoppedRun(definition.id, "missed_schedule", {
+          now: clock.now(),
+          triggeredAt: next,
+          scope,
+        })
+        publishScopedStoppedRun(stopped, scope)
         cancel(definition.id)
         return
       }
-      if (preservePendingSchedule(definition)) return
+      if (preservePendingSchedule(definition, scope)) return
       if (!tasks.has(definition.id) && definition.kind === "recurring" && hasSchedulerOwnedActiveRun(definition.id)) return
-      schedule(definition, next)
+      schedule(definition, next, scope)
     }
 
-    const unsubscribeRunUpdates = Bus.subscribe(Automation.Event.RunUpdated, (event) => {
-      if (!running) return
-      const run = event.properties
-      if (run.state === "scheduled" || run.state === "running" || run.state === "awaiting_input") return
-      const wasOwned = ownedRuns.delete(run.id)
-      const wasSchedulerStopped = schedulerStoppedRuns.delete(run.id)
-      if (run.state === "stopped" && !wasOwned && !wasSchedulerStopped) return
-      if (ownsTimers) {
-        try {
-          const refreshed = Automation.recordRunOutcome(run, {
-            now: clock.now(),
-            refreshOnStopped: wasOwned || wasSchedulerStopped,
-          })
-          if (refreshed) {
-            const key = selfUpdateKey(refreshed)
-            selfPublishedDefinitionUpdates.add(key)
-            void Automation.publishDefinitionUpdated(refreshed).catch((error) => {
-              selfPublishedDefinitionUpdates.delete(key)
-              log.error("automation derived field publish failed", { error, automationID: refreshed.id })
-            })
-          }
-        } catch (error) {
-          if (!NotFoundError.isInstance(error)) log.error("automation derived field update failed", { error, automationID: run.automationID })
+    const runScoped = (event: GlobalEventEnvelope, fn: (scope: Automation.Scope) => void | Promise<void>) => {
+      const scope = scopeFromEvent(event)
+      if (!scope) return
+      try {
+        if (sameScope(Automation.currentScope(), scope)) {
+          void Promise.resolve()
+            .then(() => fn(scope))
+            .catch((error) => log.error("automation scheduler event handling failed", { error }))
+          return
         }
+      } catch {
+        // No current instance context; enter the event owner below.
       }
-      scheduleNextInterval(run.automationID)
-    })
-    const unsubscribeDefinitionUpdates = Bus.subscribe(Automation.Event.DefinitionUpdated, (event) => {
-      if (!running) return
-      if (selfPublishedDefinitionUpdates.delete(selfUpdateKey(event.properties))) return
-      reschedule(event.properties)
-    })
-    const unsubscribeDefinitionDeletes = Bus.subscribe(Automation.Event.DefinitionDeleted, (event) => {
-      if (!running) return
-      cancel(event.properties.id)
-    })
-    // A continue automation runs inside the conversation it was created in.
-    // When that conversation is deleted, cascade-delete those automations so
-    // they don't linger pointing at a thread that no longer exists. Not gated
-    // on timer ownership — it's a local data cleanup, not a scheduling action.
-    const unsubscribeSessionDeletes = Bus.subscribe(Session.Event.Deleted, (event) => {
+      void runInScope(scope, () => fn(scope)).catch((error) => log.error("automation scheduler event handling failed", { error }))
+    }
+
+    const handleGlobalEvent = (event: GlobalEventEnvelope) => {
       if (!running) return
-      void Automation.deleteBySourceSession(event.properties.sessionID).catch((error) =>
-        log.error("automation cascade-delete on session delete failed", {
-          error,
-          sessionID: event.properties.sessionID,
-        }),
-      )
-    })
+      const payload = event.payload
+      if (!payload) return
+      if (payload.type === Automation.Event.RunUpdated.type) {
+        const scope = scopeFromEvent(event)
+        if (!scope) return
+        const run = Automation.Run.parse(payload.properties)
+        if (selfPublishedRunUpdates.delete(run.id)) return
+        if (run.state === "scheduled" || run.state === "running" || run.state === "awaiting_input") return
+        const wasOwned = ownedRuns.delete(run.id)
+        const wasSchedulerStopped = schedulerStoppedRuns.delete(run.id)
+        if (run.state === "stopped" && !wasOwned && !wasSchedulerStopped) return
+        const nextScope = refreshScopedRunOutcome(run, scope, {
+          refreshOnStopped: Boolean(wasOwned) || wasSchedulerStopped,
+        })
+        scheduleNextInterval(run.automationID, nextScope)
+        return
+      }
+      if (payload.type === Automation.Event.DefinitionUpdated.type) {
+        const scope = scopeFromEvent(event)
+        if (!scope) return
+        const definition = Automation.Definition.parse(payload.properties)
+        if (selfPublishedDefinitionUpdates.delete(selfUpdateKey(definition))) return
+        reschedule(definition, scope)
+        return
+      }
+      if (payload.type === Automation.Event.DefinitionDeleted.type) {
+        const tombstone = Automation.Tombstone.parse(payload.properties)
+        cancel(tombstone.id)
+        return
+      }
+      // A continue automation runs inside the conversation it was created in.
+      // When that conversation is deleted, cascade-delete those automations so
+      // they don't linger pointing at a thread that no longer exists. Not gated
+      // on timer ownership — it's a local data cleanup, not a scheduling action.
+      if (payload.type === Session.Event.Deleted.type) {
+        runScoped(event, () => {
+          const deleted = Session.Event.Deleted.properties.parse(payload.properties)
+          void Automation.deleteBySourceSession(deleted.sessionID).catch((error) =>
+            log.error("automation cascade-delete on session delete failed", {
+              error,
+              sessionID: deleted.sessionID,
+            }),
+          )
+        })
+      }
+    }
+
+    const onGlobalEvent = (event: GlobalEventEnvelope) => {
+      try {
+        handleGlobalEvent(event)
+      } catch (error) {
+        log.error("automation scheduler global event handling failed", { error })
+      }
+    }
+    GlobalBus.on("event", onGlobalEvent)
+    const unsubscribeGlobalEvents = () => GlobalBus.off("event", onGlobalEvent)
+
+    const scanCurrentScope = () => {
+      try {
+        const scope = Automation.currentScope()
+        for (const definition of Automation.list(scope)) reschedule(definition, scope)
+        return true
+      } catch {
+        return false
+      }
+    }
 
+    let scanAttempt: Promise<void> | undefined
     const scan = async () => {
       if (!running || !ownsTimers) return
-      for (const run of await Automation.reconcileInterruptedRuns({ now: clock.now() })) void Automation.publishRunUpdated(run)
-      for (const definition of Automation.list()) {
+      const shouldContinue = () => running && ownsTimers
+      const items = Automation.listAll()
+      const scopes = new Map<string, Automation.Scope>()
+      for (const item of items) scopes.set(scopeKey(item.scope), item.scope)
+      for (const scope of scopes.values()) {
+        if (!shouldContinue()) return
+        await Automation.reconcileInterruptedRuns({ now: clock.now(), scope })
+          .then((runs) => {
+            if (!shouldContinue()) return
+            for (const run of runs) publishScopedStoppedRun(run, scope, { scheduleNext: true })
+          })
+          .catch((error) => log.error("automation scheduler reconcile failed", { error, scope }))
+      }
+      for (const item of items) {
+        if (!shouldContinue()) return
         try {
-          reschedule(definition)
+          reschedule(item.definition, item.scope)
         } catch (error) {
-          log.error("automation scheduler scan failed", { error, automationID: definition.id })
+          log.error("automation scheduler scan failed", { error, automationID: item.definition.id })
         }
       }
     }
 
+    const requestScan = () => {
+      scanAttempt ??= scan().finally(() => {
+        scanAttempt = undefined
+      })
+      return scanAttempt
+    }
+
     const becomeOwner = async () => {
       if (!running || !ownerKey || ownerLease) return
       const lease = await Flock.tryAcquire(ownerKey).catch(() => undefined)
@@ -402,14 +567,14 @@ export namespace AutomationScheduler {
       }
       ownerLease = lease
       ownsTimers = true
-      ownerRescanTimer = setInterval(() => void scan(), ownerRescanMs)
+      ownerRescanTimer = setInterval(() => void requestScan(), ownerRescanMs)
       ownerRescanTimer.unref?.()
-      for (const run of await Automation.reconcileInterruptedRuns({ now: clock.now() })) void Automation.publishRunUpdated(run)
-      void scan()
+      await requestScan()
     }
 
     const settleOwner = () => {
-      if (!ownerKey || ownerLease || !running) return Promise.resolve()
+      if (!ownerKey || !running) return scanAttempt ?? Promise.resolve()
+      if (ownerLease) return scanAttempt ?? Promise.resolve()
       ownerAttempt ??= becomeOwner().finally(() => {
         ownerAttempt = undefined
       })
@@ -420,86 +585,66 @@ export namespace AutomationScheduler {
       void settleOwner()
       ownerRetryTimer = setInterval(() => void settleOwner(), ownerRetryMs)
       ownerRetryTimer.unref?.()
-    } else {
-      void scan()
+    } else if (!scanCurrentScope()) {
+      void requestScan()
     }
 
     const stopOwnedRuns = () => {
-      for (const runID of [...ownedRuns.keys()]) {
-        const stopped = Automation.stopRunByID(runID, "cancelled", { now: clock.now() })
-        ownedRuns.delete(runID)
-        if (stopped) void Automation.publishRunUpdated(stopped)
+      for (const [runID, owned] of [...ownedRuns.entries()]) {
+        const stop = () => {
+          const stopped = Automation.stopRunByID(runID, "cancelled", { now: clock.now() })
+          ownedRuns.delete(runID)
+          if (stopped) void Automation.publishRunUpdated(stopped)
+        }
+        try {
+          if (sameScope(Automation.currentScope(), owned.scope)) {
+            stop()
+            continue
+          }
+        } catch {
+          // No current instance context; stop under the run's recorded owner below.
+        }
+        void runInScope(owned.scope, stop).catch((error) =>
+          log.error("automation scheduler-owned run stop failed", { error, runID, automationID: owned.automationID }),
+        )
       }
     }
 
     return {
-      stop() {
+      stop(options) {
         running = false
         if (ownerRetryTimer) clearInterval(ownerRetryTimer)
         if (ownerRescanTimer) clearInterval(ownerRescanTimer)
-        unsubscribeRunUpdates()
-        unsubscribeDefinitionUpdates()
-        unsubscribeDefinitionDeletes()
-        unsubscribeSessionDeletes()
-        stopOwnedRuns()
+        unsubscribeGlobalEvents()
+        if (options?.stopRuns ?? true) stopOwnedRuns()
         for (const automationID of [...tasks.keys()]) cancel(automationID)
         if (ownerLease) void ownerLease.release().catch(() => undefined)
       },
-      stopOwnedRuns,
       settleOwner,
       reschedule,
       cancel,
-      computeNextFireAt(definition, from = clock.now()) {
-        return computeNextFireAt(definition, from)
+      computeNextFireAt(definition, from = clock.now(), scope) {
+        return computeNextFireAt(definition, from, scope)
       },
     }
   }
 
-  type OwnerState = {
-    context: InstanceContext
-    scheduler: Interface
-  }
-
-  const owners = new Map<string, OwnerState>()
-  const owner = Instance.state<OwnerState>(
-    () => {
-      const context = Instance.current
-      const state = { context, scheduler: make({ ownerKey: `automation-scheduler:${context.directory}` }) }
-      owners.set(context.directory, state)
-      return state
-    },
-    async (state) => {
-      owners.delete(state.context.directory)
-      Instance.restore(state.context, () => state.scheduler.stop())
-    },
-  )
+  const PROCESS_OWNER_KEY = "automation-scheduler:process"
+  let processScheduler: Interface | undefined
 
   export function current(): Interface {
-    return owner().scheduler
+    processScheduler ??= make({ ownerKey: PROCESS_OWNER_KEY })
+    return processScheduler
   }
 
-  export function install(scheduler: Interface): Interface {
-    const state = owner()
-    const previous = state.scheduler
-    previous.stop()
-    state.scheduler = scheduler
-    return previous
+  export function install(scheduler: Interface): void {
+    processScheduler?.stop()
+    processScheduler = scheduler
   }
 
-  export function stopCurrentOwnedRuns(): void {
-    const state = owner()
-    Instance.restore(state.context, () => state.scheduler.stopOwnedRuns())
+  export function stopProcess(options?: { stopRuns?: boolean }): void {
+    processScheduler?.stop(options)
+    processScheduler = undefined
   }
 
-  export function stopDirectoryOwnedRuns(directory: string): void {
-    const state = owners.get(directory)
-    if (!state) return
-    Instance.restore(state.context, () => state.scheduler.stopOwnedRuns())
-  }
-
-  export function stopAllOwnedRuns(): void {
-    for (const state of owners.values()) {
-      Instance.restore(state.context, () => state.scheduler.stopOwnedRuns())
-    }
-  }
 }
diff --git a/packages/opencode/src/project/instance.ts b/packages/opencode/src/project/instance.ts
index f8ac65b99..44b29e32a 100644
--- a/packages/opencode/src/project/instance.ts
+++ b/packages/opencode/src/project/instance.ts
@@ -1,4 +1,3 @@
-import { Log } from "@opencode-ai/core/util/log"
 import { Filesystem } from "@/util/filesystem"
 import { context, containsPath as containsPathInContext, type InstanceContext } from "./instance-context"
 import { Project } from "./project"
@@ -7,27 +6,11 @@ import { State } from "./state"
 export type { InstanceContext } from "./instance-context"
 
 const directories = new Set<string>()
-const log = Log.create({ service: "instance" })
 
 async function runtime() {
   return (await import("./instance-runtime")).InstanceRuntime
 }
 
-async function scheduler() {
-  return (await import("@/automation/scheduler")).AutomationScheduler
-}
-
-async function stopSchedulerOwnedRuns(kind: "current" | "directory" | "all", directory?: string) {
-  try {
-    const automationScheduler = await scheduler()
-    if (kind === "current") automationScheduler.stopCurrentOwnedRuns()
-    else if (kind === "directory" && directory) automationScheduler.stopDirectoryOwnedRuns(directory)
-    else automationScheduler.stopAllOwnedRuns()
-  } catch (error) {
-    log.error("failed to stop scheduler-owned automation runs before instance disposal", { error, kind, directory })
-  }
-}
-
 export const Instance = {
   async provide<R>(input: {
     directory: string
@@ -140,7 +123,6 @@ export const Instance = {
   },
   async dispose(input?: { mode?: "maintenance" | "force"; onCompleted?: () => void | Promise<void> }) {
     const ctx = Instance.current
-    if ((input?.mode ?? "maintenance") === "maintenance") await stopSchedulerOwnedRuns("current")
     const instanceRuntime = await runtime()
     const onCompleted = async () => {
       directories.delete(ctx.directory)
@@ -154,7 +136,6 @@ export const Instance = {
     input?: { mode?: "maintenance" | "force"; onCompleted?: () => void | Promise<void> },
   ) {
     const directory = Filesystem.resolve(inputDirectory)
-    if ((input?.mode ?? "maintenance") === "maintenance") await stopSchedulerOwnedRuns("directory", directory)
     const instanceRuntime = await runtime()
     const onCompleted = async () => {
       directories.delete(directory)
@@ -165,7 +146,6 @@ export const Instance = {
   },
   async disposeAll(input?: { mode?: "maintenance" | "force"; onCompleted?: () => void | Promise<void> }) {
     const { disposeAllLoadedInstances } = await import("./instance-store")
-    if ((input?.mode ?? "maintenance") === "maintenance") await stopSchedulerOwnedRuns("all")
     const onCompleted = async () => {
       directories.clear()
       await input?.onCompleted?.()
diff --git a/packages/opencode/src/server/instance/automation.ts b/packages/opencode/src/server/instance/automation.ts
index d6debea5a..6390c8415 100644
--- a/packages/opencode/src/server/instance/automation.ts
+++ b/packages/opencode/src/server/instance/automation.ts
@@ -232,7 +232,12 @@ export const AutomationRoutes = (): Hono =>
             }
             const definition = yield* automation.update(automationID, patch)
             if (definition.revision !== previous.revision) {
-              yield* automation.publishDefinitionUpdated(definition)
+              if (definition.where.projectID !== previous.where.projectID) {
+                yield* automation.publishDefinitionDeleted({ id: previous.id, deleted: true, revision: definition.revision })
+                yield* automation.publishDefinitionUpdatedForScope(definition, Automation.getScope(definition.id))
+              } else {
+                yield* automation.publishDefinitionUpdated(definition)
+              }
             }
             return c.json(definition)
           }),
diff --git a/packages/opencode/src/server/server.ts b/packages/opencode/src/server/server.ts
index 572eb1773..a4236fe76 100644
--- a/packages/opencode/src/server/server.ts
+++ b/packages/opencode/src/server/server.ts
@@ -1,6 +1,7 @@
 import { generateSpecs } from "hono-openapi"
 import { Hono } from "hono"
 import { adapter } from "#hono"
+import { AutomationScheduler } from "@/automation/scheduler"
 import { lazy } from "@/util/lazy"
 import { Log } from "@/util"
 import { MDNS } from "./mdns"
@@ -81,6 +82,18 @@ export async function listen(opts: {
 }): Promise<Listener> {
   const built = create(opts)
   const server = await built.runtime.listen(opts)
+  const automationScheduler = AutomationScheduler.current()
+  try {
+    await automationScheduler.settleOwner()
+  } catch (error) {
+    AutomationScheduler.stopProcess({ stopRuns: false })
+    try {
+      await server.stop(true)
+    } catch (stopError) {
+      log.error("server cleanup after scheduler settle failure failed", { error: stopError })
+    }
+    throw error
+  }
 
   const next = new URL("http://localhost")
   next.hostname = opts.hostname
@@ -107,6 +120,7 @@ export async function listen(opts: {
     stop(close?: boolean) {
       closing ??= (async () => {
         if (mdns) MDNS.unpublish()
+        AutomationScheduler.stopProcess({ stopRuns: false })
         await server.stop(close)
       })()
       return closing
diff --git a/packages/opencode/test/server/automation-routes.test.ts b/packages/opencode/test/server/automation-routes.test.ts
index b3f9cb792..58aef70ed 100644
--- a/packages/opencode/test/server/automation-routes.test.ts
+++ b/packages/opencode/test/server/automation-routes.test.ts
@@ -27,6 +27,7 @@ afterAll(() => {
 })
 
 afterEach(async () => {
+  AutomationScheduler.stopProcess({ stopRuns: false })
   await Instance.disposeAll()
 })
 
@@ -335,7 +336,6 @@ describe("automation routes", () => {
       let responseSettled = false
       AutomationScheduler.install({
         stop: () => undefined,
-        stopOwnedRuns: () => undefined,
         settleOwner: async () => {
           settled = true
           await gate.promise
@@ -367,7 +367,6 @@ describe("automation routes", () => {
       let responseSettled = false
       AutomationScheduler.install({
         stop: () => undefined,
-        stopOwnedRuns: () => undefined,
         settleOwner: async () => {
           settled = true
           await gate.promise
@@ -404,7 +403,6 @@ describe("automation routes", () => {
       const cancelled: string[] = []
       AutomationScheduler.install({
         stop: () => undefined,
-        stopOwnedRuns: () => undefined,
         settleOwner: async () => undefined,
         reschedule: () => undefined,
         cancel: (automationID) => cancelled.push(automationID),
@@ -478,7 +476,6 @@ describe("automation routes", () => {
       })
       AutomationScheduler.install({
         stop: () => undefined,
-        stopOwnedRuns: () => undefined,
         settleOwner: async () => {
           settleStarted.resolve()
           await releaseSettle.promise
@@ -844,6 +841,163 @@ describe("automation routes", () => {
     })
   })
 
+  test("moves a fresh automation to another project without changing its id or run history", async () => {
+    await using source = await tmpdir({ git: true })
+    await using target = await tmpdir({ git: true })
+    let targetProjectID: ProjectID | undefined
+    await Instance.provide({
+      directory: target.path,
+      fn: () => {
+        targetProjectID = Instance.project.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    let automationID = ""
+    let runID = ""
+    await Instance.provide({
+      directory: source.path,
+      fn: async () => {
+        const app = new Hono().route("/automation", AutomationRoutes())
+        app.onError(ErrorMiddleware)
+        const sourceProjectID = Instance.project.id
+        if (!targetProjectID) throw new Error("expected target project")
+        const created = Automation.create(recurringInput(sourceProjectID), { now: 100 })
+        if (created.kind !== "recurring") throw new Error("expected recurring automation")
+        await Automation.runNowExecuting(created.id, {
+          now: 200,
+          executor: async () => ({ sessionID: SessionID.descending(), result: "done", cost: 0 }),
+        })
+        const run = await waitForRunState(created.id, "succeeded")
+        automationID = created.id
+        runID = run.id
+
+        const response = await app.request(`/automation/${created.id}`, {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ where: { projectID: targetProjectID } }),
+        })
+        const moved = await response.json()
+
+        expect(response.status).toBe(200)
+        expect(moved).toMatchObject({
+          id: created.id,
+          revision: 2,
+          where: { projectID: targetProjectID },
+          rhythm: created.rhythm,
+          stop: created.stop,
+        })
+        expect(() => Automation.get(created.id)).toThrow()
+      },
+    })
+
+    await Instance.provide({
+      directory: target.path,
+      fn: () => {
+        if (!targetProjectID) throw new Error("expected target project")
+        const moved = Automation.get(automationID)
+        expect(moved.id).toBe(automationID)
+        expect(moved.where.projectID).toBe(targetProjectID)
+        expect(Automation.runs({ automationID }).items.map((run) => run.id)).toEqual([runID])
+      },
+    })
+  })
+
+  test("rejects moving a fresh automation to an unknown project", async () => {
+    await withAutomationApp(async ({ app, projectID }) => {
+      const created = Automation.create(recurringInput(projectID), { now: 100 })
+
+      const response = await app.request(`/automation/${created.id}`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ where: { projectID: ProjectID.make("project-missing") } }),
+      })
+
+      expect(response.status).toBe(422)
+      expect(await response.json()).toEqual({
+        error: "invalid_automation",
+        details: [{ field: "where.projectID", message: "project_not_found" }],
+      })
+      expect(Automation.get(created.id).where.projectID).toBe(projectID)
+    })
+  })
+
+  test("rejects moving a fresh automation while it has an active run", async () => {
+    await using source = await tmpdir({ git: true })
+    await using target = await tmpdir({ git: true })
+    let targetProjectID: ProjectID | undefined
+    await Instance.provide({
+      directory: target.path,
+      fn: () => {
+        targetProjectID = Instance.project.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    await Instance.provide({
+      directory: source.path,
+      fn: async () => {
+        const app = new Hono().route("/automation", AutomationRoutes())
+        app.onError(ErrorMiddleware)
+        if (!targetProjectID) throw new Error("expected target project")
+        const created = Automation.create(recurringInput(Instance.project.id), { now: 100 })
+        const active = Automation.runNow(created.id, { now: 200 })
+        await using _lease = await Flock.acquire(`automation-run:${Instance.directory}:${active.id}`)
+
+        const response = await app.request(`/automation/${created.id}`, {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ where: { projectID: targetProjectID } }),
+        })
+
+        expect(response.status).toBe(422)
+        expect(await response.json()).toEqual({
+          error: "invalid_automation",
+          details: [{ field: "where.projectID", message: "unsupported_move_with_active_run" }],
+        })
+        expect(Automation.get(created.id).where.projectID).toBe(Instance.project.id)
+      },
+    })
+  })
+
+  test("rejects moving a continue automation to another project", async () => {
+    await using source = await tmpdir({ git: true })
+    await using target = await tmpdir({ git: true })
+    let targetProjectID: ProjectID | undefined
+    await Instance.provide({
+      directory: target.path,
+      fn: () => {
+        targetProjectID = Instance.project.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    await Instance.provide({
+      directory: source.path,
+      fn: async () => {
+        const app = new Hono().route("/automation", AutomationRoutes())
+        app.onError(ErrorMiddleware)
+        if (!targetProjectID) throw new Error("expected target project")
+        const created = Automation.create(recurringInput(Instance.project.id, { context: "continue" }), {
+          sourceSessionID: SessionID.descending(),
+        })
+
+        const response = await app.request(`/automation/${created.id}`, {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ where: { projectID: targetProjectID } }),
+        })
+
+        expect(response.status).toBe(422)
+        expect(await response.json()).toEqual({
+          error: "invalid_automation",
+          details: [{ field: "where.projectID", message: "unsupported_continue_move" }],
+        })
+        expect(Automation.get(created.id).where.projectID).toBe(Instance.project.id)
+      },
+    })
+  })
+
   test("rejects updating a oneshot fireAt into the past without revising", async () => {
     await withAutomationApp(async ({ app, projectID }) => {
       const created = await json(app, "/automation", {
diff --git a/packages/opencode/test/server/automation-scheduler.test.ts b/packages/opencode/test/server/automation-scheduler.test.ts
index d53cfe291..ebad3113b 100644
--- a/packages/opencode/test/server/automation-scheduler.test.ts
+++ b/packages/opencode/test/server/automation-scheduler.test.ts
@@ -18,6 +18,7 @@ const runtime = ManagedRuntime.make(Automation.defaultLayer)
 const automation = await runtime.runPromise(Effect.gen(function* () { return yield* Automation.Service }))
 
 afterEach(async () => {
+  AutomationScheduler.stopProcess({ stopRuns: false })
   await Instance.disposeAll()
 })
 
@@ -299,6 +300,132 @@ describe("automation scheduler", () => {
     })
   })
 
+  test("fires a stored automation even when its project instance is not open", async () => {
+    await using tmp = await tmpdir({ git: true })
+    let automationID = ""
+    let projectDirectory = ""
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => {
+        projectDirectory = Instance.directory
+        const definition = Automation.create(oneshotInput(Instance.project.id, 1_000), { now: 0 })
+        automationID = definition.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    const clock = new FakeClock(0)
+    const startedIn: string[] = []
+    const scheduler = AutomationScheduler.make({
+      clock,
+      executor: async () => {
+        startedIn.push(Instance.directory)
+        return { sessionID: SessionID.descending(), result: "done", cost: 0 }
+      },
+    })
+    await scheduler.settleOwner()
+    expect(Instance.directories()).not.toContain(projectDirectory)
+
+    await clock.advance(1_000)
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const runs = await waitForRunStates(automationID, ["succeeded"])
+        expect(runs[0].triggeredAt).toBe(1_000)
+      },
+    })
+    expect(startedIn).toEqual([projectDirectory])
+    scheduler.stop()
+  })
+
+  test("records missed closed-project schedules without opening the project", async () => {
+    await using tmp = await tmpdir({ git: true })
+    let automationID = ""
+    let projectDirectory = ""
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => {
+        projectDirectory = Instance.directory
+        const definition = Automation.create(cronInput(Instance.project.id, "* * * * *"), { now: 0 })
+        automationID = definition.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    const clock = new FakeClock(120_000)
+    const scheduler = AutomationScheduler.make({ clock })
+    await scheduler.settleOwner()
+    expect(Instance.directories()).not.toContain(projectDirectory)
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => {
+        const runs = Automation.runs({ automationID }).items
+        expect(runs).toHaveLength(1)
+        expect(runs[0].state).toBe("stopped")
+        if (runs[0].state !== "stopped") throw new Error("stopped")
+        expect(runs[0].stopReason).toBe("missed_schedule")
+        expect(runs[0].triggeredAt).toBe(120_000)
+
+        const after = Automation.get(automationID)
+        if (after.kind !== "recurring") throw new Error("recurring")
+        expect(after.nextFireAt).toBe(180_000)
+      },
+    })
+    scheduler.stop()
+  })
+
+  test("does not record missed schedules after the scheduler stops during startup scan", async () => {
+    await using tmp = await tmpdir({ git: true })
+    let automationID = ""
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => {
+        const definition = Automation.create(cronInput(Instance.project.id, "* * * * *"), { now: 0 })
+        automationID = definition.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    const clock = new FakeClock(120_000)
+    const scheduler = AutomationScheduler.make({ clock })
+    scheduler.stop()
+    await Bun.sleep(0)
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => {
+        expect(Automation.runs({ automationID }).items).toEqual([])
+      },
+    })
+  })
+
+  test("owner settle waits for the initial closed-project scan", async () => {
+    await using tmp = await tmpdir({ git: true })
+    let automationID = ""
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => {
+        const definition = Automation.create(cronInput(Instance.project.id, "* * * * *"), { now: 0 })
+        automationID = definition.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    const clock = new FakeClock(120_000)
+    const scheduler = AutomationScheduler.make({
+      clock,
+      ownerKey: `automation-scheduler-test-${Date.now()}-${Math.random()}`,
+      ownerRetryMs: 60_000,
+    })
+    await scheduler.settleOwner()
+
+    const after = Automation.listAll().find((item) => item.definition.id === automationID)?.definition
+    scheduler.stop()
+    if (!after || after.kind !== "recurring") throw new Error("recurring")
+    expect(after.nextFireAt).toBe(180_000)
+  })
+
   test("schedules recurring automations created through the automate tool", async () => {
     await withAutomation(async (projectID) => {
       const clock = new FakeClock(0)
@@ -696,7 +823,7 @@ describe("automation scheduler", () => {
     })
   })
 
-  test("stops an active scheduled run when the instance is disposed", async () => {
+  test("does not stop an active scheduled run when the instance is disposed", async () => {
     await withAutomation(async (projectID) => {
       const clock = new FakeClock(0)
       const releaseRun = deferred<{ sessionID: SessionID; result: string | null; cost?: number | null }>()
@@ -718,12 +845,13 @@ describe("automation scheduler", () => {
 
       await Instance.dispose({ mode: "force" })
 
-      expect(runSignal?.aborted).toBe(true)
+      expect(runSignal?.aborted).toBe(false)
       releaseRun.resolve({ sessionID: SessionID.descending(), result: "done", cost: 0 })
+      await waitForRunStates(definition.id, ["succeeded"])
     })
   })
 
-  test("stops an active scheduled run before maintenance dispose waits for other active runs", async () => {
+  test("does not stop an active scheduled run before maintenance dispose waits for other active runs", async () => {
     await withAutomation(async (projectID) => {
       const clock = new FakeClock(0)
       const releaseRun = deferred<{ sessionID: SessionID; result: string | null; cost?: number | null }>()
@@ -747,27 +875,21 @@ describe("automation scheduler", () => {
 
       await Instance.dispose()
 
-      expect(runSignal?.aborted).toBe(true)
+      expect(runSignal?.aborted).toBe(false)
       releaseRun.resolve({ sessionID: SessionID.descending(), result: "done", cost: 0 })
-
-      const nextDefinition = Automation.create(recurringInput(projectID, 60_000, { title: "Next recurring" }), {
-        now: 60_000,
-      })
-      scheduler.reschedule(nextDefinition)
-      await clock.advance(60_000)
-      await waitForRunStates(nextDefinition.id, ["succeeded"])
+      await waitForRunStates(definition.id, ["succeeded"])
 
       releaseUnrelatedRun()
       await Bun.sleep(0)
     })
   })
 
-  test("continues maintenance dispose if scheduler pre-stop fails", async () => {
+  test("does not stop the process scheduler during maintenance dispose", async () => {
     await withAutomation(async () => {
+      let stopCalls = 0
       AutomationScheduler.install({
-        stop: () => undefined,
-        stopOwnedRuns: () => {
-          throw new Error("pre-stop failed")
+        stop: () => {
+          stopCalls += 1
         },
         settleOwner: async () => undefined,
         reschedule: () => undefined,
@@ -776,6 +898,7 @@ describe("automation scheduler", () => {
       })
 
       await expect(Instance.dispose()).resolves.toBeUndefined()
+      expect(stopCalls).toBe(0)
     })
   })
 
@@ -882,6 +1005,61 @@ describe("automation scheduler", () => {
     })
   })
 
+  test("keeps a preserved recurring timer scoped to the target project after move", async () => {
+    await using source = await tmpdir({ git: true })
+    await using target = await tmpdir({ git: true })
+    let targetScope: Automation.Scope | undefined
+    await Instance.provide({
+      directory: target.path,
+      fn: () => {
+        targetScope = Automation.currentScope()
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    const clock = new FakeClock(0)
+    const startedIn: string[] = []
+    let scheduler: AutomationScheduler.Interface | undefined
+    let automationID = ""
+    try {
+      await Instance.provide({
+        directory: source.path,
+        fn: async () => {
+          if (!targetScope) throw new Error("target scope")
+          const sourceScope = Automation.currentScope()
+          const definition = Automation.create(recurringInput(sourceScope.projectID, 60_000), { now: 0 })
+          automationID = definition.id
+          scheduler = AutomationScheduler.make({
+            clock,
+            executor: async () => {
+              startedIn.push(Instance.directory)
+              return { sessionID: SessionID.descending(), result: "done", cost: 0 }
+            },
+          })
+
+          scheduler.reschedule(definition, sourceScope)
+          await clock.advance(30_000)
+          const moved = Automation.update(definition.id, { where: { projectID: targetScope.projectID } }, { now: clock.now() })
+          scheduler.reschedule(moved, targetScope)
+          expect(() => Automation.get(definition.id)).toThrow()
+        },
+      })
+
+      await clock.advance(30_000)
+      await Instance.provide({
+        directory: target.path,
+        fn: async () => {
+          const runs = await waitForRunStates(automationID, ["succeeded"])
+          expect(runs[0].triggeredAt).toBe(60_000)
+        },
+      })
+
+      expect(startedIn).toEqual([target.path])
+    } finally {
+      scheduler?.stop()
+    }
+  })
+
   test("does not schedule a recurring timer while its scheduled run is active", async () => {
     await withAutomation(async (projectID) => {
       const clock = new FakeClock(0)
@@ -1057,6 +1235,73 @@ describe("automation scheduler", () => {
     })
   })
 
+  test("run update from the old scope refreshes a moved recurring automation", async () => {
+    await using source = await tmpdir({ git: true })
+    await using target = await tmpdir({ git: true })
+    let targetProjectID: ProjectID | undefined
+    await Instance.provide({
+      directory: target.path,
+      fn: () => {
+        targetProjectID = Instance.project.id
+      },
+    })
+    await Instance.disposeAll({ mode: "force" })
+
+    let automationID = ""
+    let sourceScope: Automation.Scope | undefined
+    let failedRun: Automation.Run | undefined
+    await Instance.provide({
+      directory: source.path,
+      fn: async () => {
+        if (!targetProjectID) throw new Error("target project")
+        sourceScope = Automation.currentScope()
+        const created = Automation.create(recurringInput(Instance.project.id, 60_000), { now: 0 })
+        if (created.kind !== "recurring") throw new Error("recurring")
+        automationID = created.id
+
+        await Automation.runNowExecuting(created.id, {
+          now: 1_000,
+          executor: async ({ run }) => {
+            const running = Automation.markRunStarted(run, SessionID.descending(), { now: 1_000 })
+            await Automation.publishRunUpdated(running)
+            throw new Error("kaboom")
+          },
+        }).catch(() => undefined)
+        failedRun = (await waitForFailedRunCount(created.id, 1)).find((run) => run.state === "failed")
+        if (!failedRun) throw new Error("failed run")
+
+        const beforeMove = Automation.get(created.id)
+        if (beforeMove.kind !== "recurring") throw new Error("recurring before move")
+        expect(beforeMove.failureStreak).toBe(0)
+        expect(beforeMove.nextFireAt).toBe(created.nextFireAt)
+
+        Automation.update(created.id, { where: { projectID: targetProjectID } }, { now: 1_400 })
+        expect(() => Automation.get(created.id)).toThrow()
+      },
+    })
+
+    const clock = new FakeClock(1_500)
+    const scheduler = AutomationScheduler.make({ clock })
+    if (!sourceScope || !failedRun) throw new Error("missing moved run fixture")
+    Automation.publishRunUpdatedForScope(failedRun, sourceScope)
+
+    const deadline = Date.now() + 3_000
+    let latest: Automation.Definition | undefined
+    while (Date.now() < deadline) {
+      latest = await Instance.provide({
+        directory: target.path,
+        fn: () => Automation.get(automationID),
+      })
+      if (latest.kind === "recurring" && latest.failureStreak === 1 && latest.nextFireAt !== null && latest.nextFireAt > 60_000) break
+      await Bun.sleep(5)
+    }
+    scheduler.stop()
+
+    if (!latest || latest.kind !== "recurring") throw new Error("recurring after move")
+    expect(latest.failureStreak).toBe(1)
+    expect(latest.nextFireAt).toBeGreaterThan(60_000)
+  })
+
   test("recordRunOutcome stays consistent across concurrent revision bumps", async () => {
     await withAutomation(async (projectID) => {
       const created = Automation.create(recurringInput(projectID, 60_000), { now: 0 })
diff --git a/packages/opencode/test/server/server-listen.test.ts b/packages/opencode/test/server/server-listen.test.ts
new file mode 100644
index 000000000..5c56d156d
--- /dev/null
+++ b/packages/opencode/test/server/server-listen.test.ts
@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test"
+import { Process } from "../../src/util/process"
+
+describe("server listen", () => {
+  test("cleans up the bound server when scheduler settle fails", async () => {
+    const script = `
+      import net from "node:net"
+      import { Server } from "./src/server/server.ts"
+      import { AutomationScheduler } from "./src/automation/scheduler.ts"
+      import { Log } from "@opencode-ai/core/util/log"
+
+      await Log.init({ print: false })
+
+      const listenOnce = (port) =>
+        new Promise((resolve, reject) => {
+          const server = net.createServer()
+          const cleanup = () => {
+            server.off("error", reject)
+            server.off("listening", ready)
+          }
+          const ready = () => {
+            cleanup()
+            const address = server.address()
+            server.close(() => resolve(address.port))
+          }
+          server.once("error", reject)
+          server.once("listening", ready)
+          server.listen(port, "127.0.0.1")
+        })
+
+      const port = await listenOnce(0)
+      let stopCalls = 0
+      AutomationScheduler.install({
+        stop: () => {
+          stopCalls += 1
+        },
+        settleOwner: async () => {
+          throw new Error("settle failed")
+        },
+        reschedule: () => undefined,
+        cancel: () => undefined,
+        computeNextFireAt: () => null,
+      })
+
+      let rejected = false
+      let message = ""
+      try {
+        await Server.listen({ port, hostname: "127.0.0.1" })
+      } catch (error) {
+        rejected = true
+        message = error instanceof Error ? error.message : String(error)
+      }
+
+      let portFreed = false
+      try {
+        await listenOnce(port)
+        portFreed = true
+      } catch {
+        portFreed = false
+      }
+
+      console.log(JSON.stringify({ rejected, message, stopCalls, portFreed }))
+      process.exit(0)
+    `
+
+    const result = await Process.run([process.execPath, "--eval", script], {
+      cwd: import.meta.dir + "/../..",
+      timeout: 5_000,
+    })
+    const lastLine = result.stdout.toString().trim().split("\n").at(-1)
+
+    expect(lastLine ? JSON.parse(lastLine) : undefined).toEqual({
+      rejected: true,
+      message: "settle failed",
+      stopCalls: 1,
+      portFreed: true,
+    })
+  }, 10_000)
+})