diff --git a/desktop/e2e/tests/actions.spec.ts b/desktop/e2e/tests/actions.spec.ts
index 4cb9c259..5dead7de 100644
--- a/desktop/e2e/tests/actions.spec.ts
+++ b/desktop/e2e/tests/actions.spec.ts
@@ -40,9 +40,9 @@ actions:
     applies_to: [pr]
     repo_template: "https://github.com/{{ .Payload.repo }}.git"
     prompt_template: |
-      Review pull request {{ .Payload.url }}: {{ .Payload.title }}
+      Review pull request {{ .Payload.title }}
 
-      {{ .Payload.body }}
+      {{ .Payload.url }}
   - id: start-implementation
     label: Start implementation
     type: launch-session
@@ -50,7 +50,9 @@ actions:
     applies_to: [issue]
     repo_template: "https://github.com/{{ .Payload.repo }}.git"
     prompt_template: |
-      Implement issue {{ .Payload.url }}: {{ .Payload.title }}
+      Work on {{ .Payload.title }}
+
+      {{ .Payload.url }}
 
       {{ .Payload.body }}
 `)
@@ -117,6 +119,12 @@ test('persists shell output, failure diagnostics, and durable duplicate rejectio
   const shell = action(state.runId, 'pr')
   await page.locator(`[data-id="${shell}"]`).click()
   await expect(page.getByTestId('toast')).toContainText('Smoke PR completed')
+  const jobsChip = page.getByTestId('titlebar-jobs')
+  await expect(jobsChip).toBeVisible()
+  await jobsChip.click()
+  await expect(page.getByTestId('jobs-popover')).toContainText('Smoke PR')
+  await expect(page.getByTestId('jobs-popover')).toContainText('Completed')
+  await expect(jobsChip).toBeHidden({ timeout: 7_000 })
   await expect.poll(async () => (await smoke(page)).outputCommands.filter((command) => command.actionId === shell)).toEqual([
     expect.objectContaining({ key: 'pr2841', status: 'done', stdout: 'smoke-stdout', stderr: 'smoke-stderr', lastError: '' }),
   ])
diff --git a/desktop/frontend/bindings/github.com/colonyops/hive/desktop/index.ts b/desktop/frontend/bindings/github.com/colonyops/hive/desktop/index.ts
index 175893e0..c9af125a 100644
--- a/desktop/frontend/bindings/github.com/colonyops/hive/desktop/index.ts
+++ b/desktop/frontend/bindings/github.com/colonyops/hive/desktop/index.ts
@@ -4,6 +4,7 @@
 import * as ActionsService from "./actionsservice.js";
 import * as ActivityService from "./activityservice.js";
 import * as FlowsService from "./flowsservice.js";
+import * as JobService from "./jobservice.js";
 import * as PipelineService from "./pipelineservice.js";
 import * as SettingsService from "./settingsservice.js";
 import * as SystemService from "./systemservice.js";
@@ -11,6 +12,7 @@ export {
     ActionsService,
     ActivityService,
     FlowsService,
+    JobService,
     PipelineService,
     SettingsService,
     SystemService
diff --git a/desktop/frontend/bindings/github.com/colonyops/hive/desktop/jobservice.ts b/desktop/frontend/bindings/github.com/colonyops/hive/desktop/jobservice.ts
new file mode 100644
index 00000000..3da42b0f
--- /dev/null
+++ b/desktop/frontend/bindings/github.com/colonyops/hive/desktop/jobservice.ts
@@ -0,0 +1,32 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+/**
+ * JobService exposes live action-run jobs to the desktop frontend. The
+ * titlebar reads active and briefly lingering jobs through ListActive, while
+ * List provides cursor-based history paging.
+ * @module
+ */
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import { Call as $Call, CancellablePromise as $CancellablePromise } from "@wailsio/runtime";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as jobs$0 from "../internal/desktop/jobs/models.js";
+
+/**
+ * List returns up to limit jobs with id < before, newest first.
+ */
+export function List(before: number, limit: number): $CancellablePromise<jobs$0.Job[] | null> {
+    return $Call.ByID(1946050826, before, limit);
+}
+
+/**
+ * ListActive returns non-terminal jobs plus terminal jobs completed within the
+ * backend-owned lingering window.
+ */
+export function ListActive(): $CancellablePromise<jobs$0.Job[] | null> {
+    return $Call.ByID(2667553212);
+}
diff --git a/desktop/frontend/bindings/github.com/colonyops/hive/internal/desktop/jobs/index.ts b/desktop/frontend/bindings/github.com/colonyops/hive/internal/desktop/jobs/index.ts
new file mode 100644
index 00000000..82e645a8
--- /dev/null
+++ b/desktop/frontend/bindings/github.com/colonyops/hive/internal/desktop/jobs/index.ts
@@ -0,0 +1,7 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+export type {
+    Job,
+    JobStatus
+} from "./models.js";
diff --git a/desktop/frontend/bindings/github.com/colonyops/hive/internal/desktop/jobs/models.ts b/desktop/frontend/bindings/github.com/colonyops/hive/internal/desktop/jobs/models.ts
new file mode 100644
index 00000000..9a27f23c
--- /dev/null
+++ b/desktop/frontend/bindings/github.com/colonyops/hive/internal/desktop/jobs/models.ts
@@ -0,0 +1,27 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+/**
+ * Job is one action-run lifecycle row. ID, CreatedAt, and UpdatedAt are
+ * assigned by the store. CreatedAt and UpdatedAt are unix milliseconds. Step
+ * is a human label derived from Status in v1.
+ */
+export interface Job {
+    "id": number;
+    "createdAt": number;
+    "updatedAt": number;
+    "status": JobStatus;
+    "label": string;
+    "step": string;
+    "actionId": string;
+    "target": string;
+    "error"?: string;
+    "commandId"?: number | null;
+}
+
+/**
+ * JobStatus is a job's lifecycle stage.
+ * 
+ * ENUM(queued, running, done, failed)
+ */
+export type JobStatus = string;
diff --git a/desktop/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts b/desktop/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts
index 63d0f03f..7a04e21a 100644
--- a/desktop/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts
+++ b/desktop/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts
@@ -12,6 +12,7 @@ declare module "@wailsio/runtime" {
             "activity:appended": number;
             "auth:updated": string;
             "flows:updated": string;
+            "jobs:updated": string;
             "log:appended": number;
         }
     }
diff --git a/desktop/frontend/src/App.vue b/desktop/frontend/src/App.vue
index 2e2efd67..0d2bb5a1 100644
--- a/desktop/frontend/src/App.vue
+++ b/desktop/frontend/src/App.vue
@@ -28,6 +28,7 @@ import ToastStack from './components/ToastStack.vue'
 import DevBar from './components/DevBar.vue'
 import { useAuth } from './composables/useAuth'
 import { useActivity } from './composables/useActivity'
+import { useJobs } from './composables/useJobs'
 import { useFeedState } from './composables/useFeedState'
 import { useCommands, useCommandPalette, type Command } from './composables/useCommands'
 import { comboFromEvent, formatCombo, useKeybindings } from './composables/useKeybindings'
@@ -51,7 +52,7 @@ const {
   profiles, profilesLoaded, profilesError, activeProfile, activeProfileId, selection, items, visibleItems, unreadCount, search, loadError,
   selectedId, selectedItem, actions, pendingAction, actionRuns, sessionLaunchAction, sessionLaunchOptions, sessionLaunchBusy, sessionLaunchError, unreadOnly, feedSort, setFeedSort, title, toasts, dismissToast, clearToasts,
   creatingProfile, createProfileError, renamingProfile, renameProfileError, deletingProfile, loadProfiles, createProfile, renameProfile, deleteProfile,
-  reorderFeeds, selectProfile, selectSidebar, selectUnreadView, selectItem, selectNext, selectPrev,
+  reorderFeeds, selectProfile, selectSidebar, selectUnreadView, selectItem, openActionRun, selectNext, selectPrev,
   toggleUnread, refresh, invokeAction, cancelSessionLaunch, submitSessionLaunch, notWired, openUrl, openSelectedInBrowser, hideWindow,
 } = useFeedState()
 
@@ -256,11 +257,21 @@ function requestOpenSettings(page: 'application' | 'profile'): void {
 // App-global audit log. The titlebar's Activity link replaces the old "polling
 // github" indicator; unseenActivity drives its dot.
 const { unseenCount: unseenActivity } = useActivity()
+const { activeJobs, hasActive: jobsActive } = useJobs()
 
 function openActivity(): void {
   void router.push({ name: 'activity' })
 }
 
+async function openJobRun(commandID: number): Promise<void> {
+  const job = activeJobs.value.find((candidate) => candidate.commandId === commandID)
+  if (!job || !activeProfileId.value) return
+  await router.push({ name: 'feed', params: { profileId: activeProfileId.value } })
+  if (route.name !== 'feed') return
+  await selectSidebar({ type: 'all' })
+  await openActionRun(job.target, job.actionId, commandID)
+}
+
 function closeSettings(): void {
   openFeed()
 }
@@ -586,6 +597,8 @@ onUnmounted(() => {
         :activity-active="activityActive"
         :error-count="errorCount"
         :unseen-activity="unseenActivity"
+        :jobs-active="jobsActive"
+        :active-jobs="activeJobs"
         :can-go-back="canGoBack"
         :can-go-forward="canGoForward"
         :sidebar-collapsed="sidebarCollapsed"
@@ -594,6 +607,7 @@ onUnmounted(() => {
         @forward="router.forward()"
         @open-error-node="openErrorNode"
         @open-activity="openActivity"
+        @open-job-run="openJobRun"
         @toggle-sidebar="toggleSidebar"
         @open-palette="togglePalette"
         @toggle-maximise="toggleMaximise"
diff --git a/desktop/frontend/src/components/JobsPopover.vue b/desktop/frontend/src/components/JobsPopover.vue
new file mode 100644
index 00000000..50b8ab05
--- /dev/null
+++ b/desktop/frontend/src/components/JobsPopover.vue
@@ -0,0 +1,59 @@
+<script setup lang="ts">
+import IconCheck from '~icons/lucide/check'
+import IconCircleAlert from '~icons/lucide/circle-alert'
+import IconClock3 from '~icons/lucide/clock-3'
+import IconExternalLink from '~icons/lucide/external-link'
+import IconLoader from '~icons/lucide/loader'
+import type { Job } from '../../bindings/github.com/colonyops/hive/internal/desktop/jobs/models'
+
+defineProps<{ jobs: Job[] }>()
+const emit = defineEmits<{ 'open-run': [commandId: number] }>()
+
+function statusClasses(status: string): string {
+  if (status === 'failed') return 'border-severity-error-border bg-severity-error-tint text-severity-error'
+  if (status === 'done') return 'border-severity-success-border bg-severity-success-tint text-severity-success'
+  return 'border-border bg-chip text-text-2'
+}
+</script>
+
+<template>
+  <section
+    class="absolute right-0 top-[calc(100%+6px)] z-50 w-[340px] overflow-hidden rounded-lg border border-border bg-raised shadow-xl"
+    style="--wails-draggable: no-drag"
+    role="dialog"
+    aria-label="Action jobs"
+    data-testid="jobs-popover"
+  >
+    <header class="border-b border-border px-3.5 py-2.5">
+      <div class="text-xs font-semibold text-text">Action jobs</div>
+      <div class="mt-0.5 text-[10.5px] text-text-3">Running and recently completed work</div>
+    </header>
+    <ul class="max-h-80 divide-y divide-border overflow-y-auto">
+      <li v-for="job in jobs" :key="job.id" class="flex items-start gap-2.5 px-3.5 py-3" :data-testid="`job-row-${job.id}`">
+        <span class="mt-0.5 flex size-6 shrink-0 items-center justify-center rounded-full border" :class="statusClasses(job.status)">
+          <IconLoader v-if="job.status === 'running'" class="size-3.5 animate-spin" />
+          <IconClock3 v-else-if="job.status === 'queued'" class="size-3.5" />
+          <IconCheck v-else-if="job.status === 'done'" class="size-3.5" />
+          <IconCircleAlert v-else class="size-3.5" />
+        </span>
+        <div class="min-w-0 flex-1">
+          <div class="truncate text-[12px] font-medium text-text">{{ job.label || job.actionId }}</div>
+          <div class="mt-0.5 flex items-center gap-1.5 text-[10.5px]">
+            <span :class="job.status === 'failed' ? 'text-severity-error' : 'text-text-3'">{{ job.step }}</span>
+            <span v-if="job.target" class="truncate text-text-4">· {{ job.target }}</span>
+          </div>
+          <div v-if="job.error" class="mt-1 line-clamp-2 text-[10.5px] text-severity-error">{{ job.error }}</div>
+        </div>
+        <button
+          v-if="job.commandId"
+          type="button"
+          class="mt-0.5 flex size-6 shrink-0 cursor-pointer items-center justify-center rounded text-text-3 hover:bg-chip hover:text-text"
+          :aria-label="`Open action run for ${job.label || job.actionId}`"
+          title="Open action run"
+          :data-testid="`job-open-run-${job.id}`"
+          @click="emit('open-run', job.commandId)"
+        ><IconExternalLink class="size-3.5" /></button>
+      </li>
+    </ul>
+  </section>
+</template>
diff --git a/desktop/frontend/src/components/TitleBar.vue b/desktop/frontend/src/components/TitleBar.vue
index 002a83e6..25f70616 100644
--- a/desktop/frontend/src/components/TitleBar.vue
+++ b/desktop/frontend/src/components/TitleBar.vue
@@ -1,4 +1,6 @@
 <script setup lang="ts">
+import { onClickOutside } from '@vueuse/core'
+import { ref, watch } from 'vue'
 import IconActivity from '~icons/lucide/activity'
 import IconArrowLeft from '~icons/lucide/arrow-left'
 import IconArrowRight from '~icons/lucide/arrow-right'
@@ -6,6 +8,9 @@ import IconPanelLeftClose from '~icons/lucide/panel-left-close'
 import IconPanelLeftOpen from '~icons/lucide/panel-left-open'
 import IconSearch from '~icons/lucide/search'
 import IconTriangleAlert from '~icons/lucide/triangle-alert'
+import IconLoader from '~icons/lucide/loader'
+import JobsPopover from './JobsPopover.vue'
+import type { Job } from '../../bindings/github.com/colonyops/hive/internal/desktop/jobs/models'
 
 // The bar is a three-column grid: a left cluster (sidebar toggle), a center
 // cluster (history + command-palette launcher) that stays centered in the
@@ -20,11 +25,13 @@ import IconTriangleAlert from '~icons/lucide/triangle-alert'
 // events recorded since the user last opened that page, shown as a pulsing dot.
 // sidebarCollapsed drives the panel-toggle glyph; canToggleSidebar hides the
 // toggle in views that have no feed sidebar (settings, flows, onboarding).
-defineProps<{
+const props = defineProps<{
   profileName?: string
   activityActive?: boolean
   errorCount?: number
   unseenActivity?: number
+  jobsActive?: boolean
+  activeJobs?: Job[]
   canGoBack?: boolean
   canGoForward?: boolean
   sidebarCollapsed?: boolean
@@ -35,6 +42,7 @@ const emit = defineEmits<{
   forward: []
   'open-error-node': []
   'open-activity': []
+  'open-job-run': [commandId: number]
   'toggle-sidebar': []
   'open-palette': []
   'toggle-maximise': []
@@ -45,6 +53,11 @@ const emit = defineEmits<{
 // them and keep the height in sync with InvisibleTitleBarHeight (42) in main.go
 // so the controls stay vertically centered.
 const isMac = navigator.userAgent.includes('Mac')
+const jobsRoot = ref<HTMLElement | null>(null)
+const jobsOpen = ref(false)
+
+onClickOutside(jobsRoot, () => { jobsOpen.value = false })
+watch(() => props.jobsActive, (active) => { if (!active) jobsOpen.value = false })
 
 // Double-clicking the draggable title bar zooms the window, matching the native
 // macOS title-bar gesture (we draw our own chrome, so we implement it). Clicks
@@ -111,7 +124,7 @@ function onTitlebarDblclick(event: MouseEvent): void {
     </div>
     <div v-else class="flex-1" />
 
-    <!-- Right: error / activity chips -->
+    <!-- Right: error / live jobs / activity chips -->
     <div class="flex min-w-0 flex-1 items-center justify-end gap-2 pl-2 pr-3">
       <button
         v-if="errorCount && errorCount > 0"
@@ -120,6 +133,24 @@ function onTitlebarDblclick(event: MouseEvent): void {
         data-testid="titlebar-error-chip"
         @click="emit('open-error-node')"
       ><IconTriangleAlert class="size-3" />{{ errorCount }} error<template v-if="errorCount !== 1">s</template></button>
+      <div v-if="profileName && jobsActive" ref="jobsRoot" class="relative shrink-0" style="--wails-draggable: no-drag">
+        <button
+          type="button"
+          class="flex cursor-pointer items-center gap-1.5 rounded-md border border-accent/50 bg-accent/10 px-2 py-1 text-[11.5px] font-medium text-accent hover:border-accent"
+          data-testid="titlebar-jobs"
+          aria-label="Show action jobs"
+          :aria-expanded="jobsOpen"
+          @click="jobsOpen = !jobsOpen"
+        >
+          <IconLoader class="size-3.5 animate-spin" />
+          {{ activeJobs?.length ?? 0 }} job<template v-if="(activeJobs?.length ?? 0) !== 1">s</template>
+        </button>
+        <JobsPopover
+          v-if="jobsOpen"
+          :jobs="activeJobs ?? []"
+          @open-run="(commandId) => { jobsOpen = false; emit('open-job-run', commandId) }"
+        />
+      </div>
       <!-- A link to the Activity audit log. A pulsing dot flags activity
            recorded since the page was last opened. -->
       <button
diff --git a/desktop/frontend/src/components/__tests__/TitleBar.spec.ts b/desktop/frontend/src/components/__tests__/TitleBar.spec.ts
index 7e12ef3e..04929974 100644
--- a/desktop/frontend/src/components/__tests__/TitleBar.spec.ts
+++ b/desktop/frontend/src/components/__tests__/TitleBar.spec.ts
@@ -34,6 +34,24 @@ describe('TitleBar', () => {
     expect(active.find('[data-testid="titlebar-activity-unseen"]').exists()).toBe(false)
   })
 
+  it('shows live jobs, opens the popover, and emits the selected command', async () => {
+    const job = {
+      id: 7, createdAt: 1, updatedAt: 2, status: 'done', label: 'Review PR',
+      step: 'Completed', actionId: 'review', target: 'pr-1', commandId: 42,
+    }
+    const wrapper = mount(TitleBar, { props: { profileName: 'Triage', jobsActive: true, activeJobs: [job] } })
+    const chip = wrapper.find('[data-testid="titlebar-jobs"]')
+    expect(chip.exists()).toBe(true)
+    expect(chip.text()).toContain('1 job')
+    await chip.trigger('click')
+    expect(wrapper.find('[data-testid="jobs-popover"]').exists()).toBe(true)
+    await wrapper.find('[data-testid="job-open-run-7"]').trigger('click')
+    expect(wrapper.emitted('open-job-run')).toEqual([[42]])
+
+    await wrapper.setProps({ jobsActive: false })
+    expect(wrapper.find('[data-testid="titlebar-jobs"]').exists()).toBe(false)
+  })
+
   it('exposes enabled back and forward history controls', async () => {
     const wrapper = mount(TitleBar, { props: { profileName: 'Triage', canGoBack: true, canGoForward: true } })
 
diff --git a/desktop/frontend/src/composables/__tests__/useJobs.spec.ts b/desktop/frontend/src/composables/__tests__/useJobs.spec.ts
new file mode 100644
index 00000000..ff8f8722
--- /dev/null
+++ b/desktop/frontend/src/composables/__tests__/useJobs.spec.ts
@@ -0,0 +1,100 @@
+import { flushPromises } from '@vue/test-utils'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  ListActive: vi.fn(),
+  On: vi.fn(),
+}))
+
+vi.mock('../../../bindings/github.com/colonyops/hive/desktop/jobservice', () => ({
+  ListActive: mocks.ListActive,
+}))
+vi.mock('@wailsio/runtime', () => ({ Events: { On: mocks.On } }))
+
+function job(status: string, id = 1) {
+  return {
+    id, createdAt: 1, updatedAt: 1, status, label: 'Review', step: status,
+    actionId: 'review', target: 'item-1', commandId: 12,
+  }
+}
+
+async function loadComposable() {
+  const { useJobs } = await import('../useJobs')
+  return useJobs()
+}
+
+describe('useJobs', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+    mocks.On.mockReturnValue(() => {})
+    mocks.ListActive.mockResolvedValue([])
+  })
+
+  afterEach(() => vi.useRealTimers())
+
+  it('subscribes once and reloads on jobs:updated', async () => {
+    const jobs = await loadComposable()
+    await flushPromises()
+    const again = await loadComposable()
+    expect(again.activeJobs).toBe(jobs.activeJobs)
+    expect(mocks.On).toHaveBeenCalledTimes(1)
+    expect(mocks.On.mock.calls[0][0]).toBe('jobs:updated')
+
+    mocks.ListActive.mockResolvedValue([job('running')])
+    mocks.On.mock.calls[0][1]()
+    await vi.waitFor(() => expect(jobs.hasActive.value).toBe(true))
+  })
+
+  it('drops a stale earlier read', async () => {
+    let resolveFirst!: (rows: ReturnType<typeof job>[]) => void
+    let resolveSecond!: (rows: ReturnType<typeof job>[]) => void
+    mocks.ListActive
+      .mockImplementationOnce(() => new Promise((resolve) => { resolveFirst = resolve }))
+      .mockImplementationOnce(() => new Promise((resolve) => { resolveSecond = resolve }))
+
+    const jobs = await loadComposable()
+    mocks.On.mock.calls[0][1]()
+    resolveSecond([job('running', 2)])
+    await flushPromises()
+    resolveFirst([])
+    await flushPromises()
+
+    expect(jobs.activeJobs.value.map((row) => row.id)).toEqual([2])
+  })
+
+  it('retries a failed trailing read while terminal rows remain', async () => {
+    vi.useFakeTimers()
+    mocks.ListActive
+      .mockResolvedValueOnce([job('done')])
+      .mockRejectedValueOnce(new Error('temporary failure'))
+      .mockResolvedValueOnce([])
+
+    const jobs = await loadComposable()
+    await flushPromises()
+    await vi.advanceTimersByTimeAsync(500)
+    await flushPromises()
+    expect(jobs.hasActive.value).toBe(true)
+    await vi.advanceTimersByTimeAsync(500)
+    await flushPromises()
+
+    expect(mocks.ListActive).toHaveBeenCalledTimes(3)
+    expect(jobs.hasActive.value).toBe(false)
+  })
+
+  it('keeps polling terminal rows until the backend drops them', async () => {
+    vi.useFakeTimers()
+    mocks.ListActive
+      .mockResolvedValueOnce([job('done')])
+      .mockResolvedValueOnce([])
+
+    const jobs = await loadComposable()
+    await flushPromises()
+    expect(jobs.hasActive.value).toBe(true)
+    await vi.advanceTimersByTimeAsync(500)
+    await flushPromises()
+
+    expect(mocks.ListActive).toHaveBeenCalledTimes(2)
+    expect(jobs.hasActive.value).toBe(false)
+  })
+})
diff --git a/desktop/frontend/src/composables/useFeedState.ts b/desktop/frontend/src/composables/useFeedState.ts
index e842ed3b..57e0d632 100644
--- a/desktop/frontend/src/composables/useFeedState.ts
+++ b/desktop/frontend/src/composables/useFeedState.ts
@@ -467,6 +467,22 @@ export function useFeedState() {
     if (item) await markItemRead(item)
   }
 
+  // Opens the existing ActionCard run detail for a persisted job. Jobs carry
+  // the feed-item key and action id, so no second run-detail UI is needed.
+  async function openActionRun(itemID: string, actionID: string, commandID: number): Promise<boolean> {
+    const item = items.value.find((candidate) => candidate.id === itemID)
+    if (!item) return false
+    await selectItem(itemID)
+    try {
+      const run = await ActionRun(commandID)
+      setActionRun(itemID, actionID, run)
+      return true
+    } catch (error) {
+      console.warn('Unable to open action run', error)
+      return false
+    }
+  }
+
   async function markItemRead(item: FeedItem) {
     if (!item.unread) return
     try {
@@ -728,6 +744,7 @@ export function useFeedState() {
     selectSidebar,
     selectUnreadView,
     selectItem,
+    openActionRun,
     selectNext,
     selectPrev,
     toggleUnread,
diff --git a/desktop/frontend/src/composables/useJobs.ts b/desktop/frontend/src/composables/useJobs.ts
new file mode 100644
index 00000000..5a9f8b6f
--- /dev/null
+++ b/desktop/frontend/src/composables/useJobs.ts
@@ -0,0 +1,66 @@
+import { computed, ref } from 'vue'
+import { Events } from '@wailsio/runtime'
+import { ListActive } from '../../bindings/github.com/colonyops/hive/desktop/jobservice'
+import type { Job } from '../../bindings/github.com/colonyops/hive/internal/desktop/jobs/models'
+
+// useJobs is a module singleton: the titlebar chip and popover share one live
+// list and one app-lifetime jobs:updated subscription. The backend owns the
+// terminal-job linger window; this client only keeps re-reading while terminal
+// rows remain so they eventually fall out of the authoritative result.
+
+const TRAILING_READ_INTERVAL_MS = 500
+
+const activeJobs = ref<Job[]>([])
+const hasActive = computed(() => activeJobs.value.length > 0)
+
+let started = false
+let loadSequence = 0
+let trailingTimer: ReturnType<typeof setTimeout> | undefined
+
+function isTerminal(job: Job): boolean {
+  return job.status === 'done' || job.status === 'failed'
+}
+
+function clearTrailingRead(): void {
+  if (trailingTimer === undefined) return
+  clearTimeout(trailingTimer)
+  trailingTimer = undefined
+}
+
+function scheduleTrailingRead(): void {
+  if (trailingTimer !== undefined) return
+  trailingTimer = setTimeout(() => {
+    trailingTimer = undefined
+    void load()
+  }, TRAILING_READ_INTERVAL_MS)
+}
+
+async function load(): Promise<void> {
+  const sequence = ++loadSequence
+  try {
+    const rows = (await ListActive()) ?? []
+    if (sequence !== loadSequence) return
+    activeJobs.value = rows
+    if (rows.some(isTerminal)) scheduleTrailingRead()
+    else clearTrailingRead()
+  } catch (error) {
+    if (sequence === loadSequence) {
+      console.warn('Unable to load active jobs', error)
+      if (activeJobs.value.some(isTerminal)) scheduleTrailingRead()
+    }
+  }
+}
+
+function start(): void {
+  if (started) return
+  started = true
+  // The singleton lives for the app lifetime, so this subscription is
+  // intentionally never removed.
+  Events.On('jobs:updated', () => { void load() })
+  void load()
+}
+
+export function useJobs() {
+  start()
+  return { activeJobs, hasActive }
+}
diff --git a/desktop/jobservice.go b/desktop/jobservice.go
new file mode 100644
index 00000000..9e4e446d
--- /dev/null
+++ b/desktop/jobservice.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"context"
+
+	"github.com/colonyops/hive/internal/desktop/jobs"
+)
+
+// JobService exposes live action-run jobs to the desktop frontend. The
+// titlebar reads active and briefly lingering jobs through ListActive, while
+// List provides cursor-based history paging.
+type JobService struct {
+	store *jobs.Store
+}
+
+// NewJobService builds a JobService over store.
+func NewJobService(store *jobs.Store) *JobService {
+	return &JobService{store: store}
+}
+
+// List returns up to limit jobs with id < before, newest first.
+func (s *JobService) List(before int64, limit int) ([]jobs.Job, error) {
+	return s.store.List(context.Background(), before, limit)
+}
+
+// ListActive returns non-terminal jobs plus terminal jobs completed within the
+// backend-owned lingering window.
+func (s *JobService) ListActive() ([]jobs.Job, error) {
+	return s.store.ListActive(context.Background(), jobs.DefaultLingerWindow)
+}
diff --git a/desktop/jobservice_test.go b/desktop/jobservice_test.go
new file mode 100644
index 00000000..38656fd7
--- /dev/null
+++ b/desktop/jobservice_test.go
@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/colonyops/hive/internal/desktop/jobs"
+	"github.com/colonyops/hive/internal/desktop/pipeline/pipelinedb"
+)
+
+func TestJobService_ListAndListActive(t *testing.T) {
+	db, err := pipelinedb.Open(t.TempDir(), pipelinedb.DefaultOpenOptions())
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, db.Close()) })
+
+	now := time.Date(2026, 7, 21, 12, 0, 0, 0, time.UTC)
+	store := jobs.NewStore(db, jobs.Options{Now: func() time.Time { return now }})
+	service := NewJobService(store)
+	ctx := context.Background()
+
+	outside, err := db.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: now.Add(-time.Minute).UnixMilli(), UpdatedAt: now.Add(-jobs.DefaultLingerWindow - time.Millisecond).UnixMilli(),
+		Status: "done", Label: "Outside", Step: "Completed",
+	})
+	require.NoError(t, err)
+	inside, err := db.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: now.Add(-time.Minute).UnixMilli(), UpdatedAt: now.Add(-jobs.DefaultLingerWindow + time.Millisecond).UnixMilli(),
+		Status: "failed", Label: "Inside", Step: "Failed",
+	})
+	require.NoError(t, err)
+	queued, err := db.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: now.Add(-time.Hour).UnixMilli(), UpdatedAt: now.Add(-time.Hour).UnixMilli(),
+		Status: "queued", Label: "Queued", Step: "Queued",
+	})
+	require.NoError(t, err)
+
+	active, err := service.ListActive()
+	require.NoError(t, err)
+	require.Len(t, active, 2)
+	assert.Equal(t, []int64{queued.ID, inside.ID}, []int64{active[0].ID, active[1].ID})
+
+	page, err := service.List(0, 2)
+	require.NoError(t, err)
+	require.Len(t, page, 2)
+	assert.Equal(t, []int64{queued.ID, inside.ID}, []int64{page[0].ID, page[1].ID})
+
+	older, err := service.List(page[1].ID, 2)
+	require.NoError(t, err)
+	require.Len(t, older, 1)
+	assert.Equal(t, outside.ID, older[0].ID)
+}
diff --git a/desktop/main.go b/desktop/main.go
index 503fbb41..6d449b8b 100644
--- a/desktop/main.go
+++ b/desktop/main.go
@@ -22,6 +22,7 @@ import (
 	"github.com/colonyops/hive/internal/desktop/activity"
 	"github.com/colonyops/hive/internal/desktop/auth"
 	"github.com/colonyops/hive/internal/desktop/feed"
+	"github.com/colonyops/hive/internal/desktop/jobs"
 	"github.com/colonyops/hive/internal/desktop/pipeline"
 	"github.com/colonyops/hive/internal/desktop/pipeline/actions"
 	"github.com/colonyops/hive/internal/desktop/pipeline/flow"
@@ -62,6 +63,7 @@ func registerEvents() struct{} {
 	application.RegisterEvent[int64]("log:appended")
 	application.RegisterEvent[string]("flows:updated")
 	application.RegisterEvent[string]("actions:updated")
+	application.RegisterEvent[string]("jobs:updated")
 	// activity:appended carries the new event's id after any subsystem (or the
 	// frontend, via ActivityService.Record) appends to the activity log. The
 	// Activity view re-reads its latest page and advances its unseen marker.
@@ -123,6 +125,14 @@ func emitActivityAppended(id int64) {
 	}
 }
 
+// emitJobsUpdated wakes frontend consumers after any successful job lifecycle
+// transition. The payload is intentionally only a wake-up signal.
+func emitJobsUpdated() {
+	if app := application.Get(); app != nil {
+		app.Event.Emit("jobs:updated", "changed")
+	}
+}
+
 // emitAuthUpdated pushes the auth:updated wake-up to the frontend. Safe to
 // call from any goroutine once the app is running.
 func emitAuthUpdated() {
@@ -295,7 +305,7 @@ func buildHiveActionRuntime(recorder activity.Recorder, logger zerolog.Logger) (
 // output commands, but they retain this worker for explicit detail-pane
 // confirmation RPCs. That keeps the configured action path real in e2e while
 // avoiding a background shell action from compromising fixture determinism.
-func buildOutputWorker(db *pipelinedb.DB, actionStore *actions.ActionStore, launcher pipeline.SessionLauncher, publisher pipeline.MessagePublisher, recorder activity.Recorder, logger zerolog.Logger) *pipeline.Worker {
+func buildOutputWorker(db *pipelinedb.DB, actionStore *actions.ActionStore, launcher pipeline.SessionLauncher, publisher pipeline.MessagePublisher, recorder activity.Recorder, jobRecorder jobs.Recorder, logger zerolog.Logger) *pipeline.Worker {
 	dispatcher := pipeline.NewDispatcher(map[string]pipeline.Executor{
 		pipeline.ActionTypeLaunchSession: pipeline.NewLaunchSessionExecutor(launcher),
 		"shell":                          pipeline.NewShellExecutor(logger),
@@ -303,6 +313,7 @@ func buildOutputWorker(db *pipelinedb.DB, actionStore *actions.ActionStore, laun
 	})
 	worker := pipeline.NewWorker(db, actionStore, dispatcher, pipeline.DefaultOutputWorkerInterval, logger)
 	worker.SetRecorder(recorder)
+	worker.SetJobRecorder(jobRecorder)
 	return worker
 }
 
@@ -349,6 +360,7 @@ func main() {
 	// the ActivityService the frontend reads/writes. It emits activity:appended
 	// on each append so open views refresh.
 	activityStore := activity.NewStore(pipelineDB, activity.Options{Emit: emitActivityAppended})
+	jobStore := jobs.NewStore(pipelineDB, jobs.Options{Emit: func(int64) { emitJobsUpdated() }})
 	if fetcher != nil {
 		fetcher.SetRecorder(activityStore)
 	}
@@ -381,7 +393,7 @@ func main() {
 		flowsWatcher.Start()
 	}
 
-	outputWorker := buildOutputWorker(pipelineDB, actionStore, actionRuntime.launcher, actionRuntime.publisher, activityStore, logger)
+	outputWorker := buildOutputWorker(pipelineDB, actionStore, actionRuntime.launcher, actionRuntime.publisher, activityStore, jobStore, logger)
 	if desktop.MockMode() == "" {
 		outputWorker.Start()
 	}
@@ -420,6 +432,7 @@ func main() {
 			application.NewService(NewFlowsService(flowsStore)),
 			application.NewService(NewActionsService(actionStore, emitActionsUpdated)),
 			application.NewService(NewActivityService(activityStore)),
+			application.NewService(NewJobService(jobStore)),
 			application.NewService(NewSystemService()),
 			application.NewService(NewSettingsService(producer, fetcher, logger)),
 		},
diff --git a/internal/desktop/feed/live.go b/internal/desktop/feed/live.go
index 2953febf..fc5f38d2 100644
--- a/internal/desktop/feed/live.go
+++ b/internal/desktop/feed/live.go
@@ -447,7 +447,7 @@ func (p *LiveProvider) searchItems(items []github.SearchItem) []liveItem {
 			Labels:    labelNames(si.Labels),
 			Branch:    suggestedBranch(kind, si.Number, si.Title),
 			Body:      si.Body,
-			Prompt:    suggestedPrompt(kind, repo, si.Number, si.Title),
+			Prompt:    suggestedPrompt(kind, si.Title, si.URL, si.Body),
 			URL:       si.URL,
 		}
 		out = append(out, liveItem{item: item, updatedAt: si.UpdatedAt})
@@ -482,7 +482,7 @@ func (p *LiveProvider) notificationItems(notifications []github.Notification) []
 			Reason:    n.Reason,
 			Branch:    suggestedBranch(kind, num, n.Subject.Title),
 			Body:      fmt.Sprintf("GitHub notification for %s in %s.", strings.ToLower(kind), repo),
-			Prompt:    suggestedPrompt(kind, repo, num, n.Subject.Title),
+			Prompt:    suggestedPrompt(kind, n.Subject.Title, htmlURLForSubject(repo, kind, num), ""),
 			URL:       htmlURLForSubject(repo, kind, num),
 		}
 		out = append(out, liveItem{item: item, updatedAt: n.UpdatedAt})
@@ -529,20 +529,28 @@ func labelNames(labels []github.Label) []string {
 	return names
 }
 
-// suggestedBranch proposes a session branch name for acting on the item.
+// suggestedBranch proposes a session branch name for acting on the item. The
+// naming mirrors the hive TUI's source session-name convention
+// (gh-pr-<n>-<slug> for PRs, gh-<n>-<slug> for issues; see SourceTemplateConfig
+// defaults in internal/core/config), slugified so it is a valid git branch.
 func suggestedBranch(kind string, num int, title string) string {
-	prefix := "feat"
+	prefix := "gh"
 	if kind == "PR" {
-		prefix = "review"
+		prefix = "gh-pr"
 	}
-	return fmt.Sprintf("%s/%d-%s", prefix, num, slugify(title))
+	return fmt.Sprintf("%s-%d-%s", prefix, num, slugify(title))
 }
 
-func suggestedPrompt(kind, repo string, num int, title string) string {
+// suggestedPrompt proposes the launch dialog's default prompt for an item. The
+// wording mirrors the hive TUI's source prompt templates (SourceTemplateConfig
+// defaults): PRs get "Review pull request", issues get "Work on", each followed
+// by the item URL and (for issues) its body. The result is trimmed so an empty
+// body leaves no dangling blank lines, matching the TUI.
+func suggestedPrompt(kind, title, url, body string) string {
 	if kind == "PR" {
-		return fmt.Sprintf("Review PR #%d in %s: %s. Read the diff, evaluate the approach, and summarize risks.", num, repo, title)
+		return strings.TrimSpace(fmt.Sprintf("Review pull request %s\n\n%s", title, url))
 	}
-	return fmt.Sprintf("Investigate issue #%d in %s: %s. Research the code paths involved and propose an implementation.", num, repo, title)
+	return strings.TrimSpace(fmt.Sprintf("Work on %s\n\n%s\n\n%s", title, url, body))
 }
 
 const slugMaxLen = 40
diff --git a/internal/desktop/jobs/jobs.go b/internal/desktop/jobs/jobs.go
new file mode 100644
index 00000000..37310b91
--- /dev/null
+++ b/internal/desktop/jobs/jobs.go
@@ -0,0 +1,50 @@
+// Package jobs is the desktop app's live action-run lifecycle. Unlike the
+// activity audit log (terminal events only), a job is written at every
+// transition (queued -> running -> done|failed) so the titlebar spinner chip
+// can show in-flight work. A job links to its originating output_command via a
+// nullable CommandID so the popover can deep-link to ActionRun detail.
+package jobs
+
+import "time"
+
+// DefaultLingerWindow is how long terminal jobs remain in the live-jobs view.
+// The backend owns this window so frontend clients do not need a matching
+// timeout constant.
+const DefaultLingerWindow = 4 * time.Second
+
+// JobStatus is a job's lifecycle stage.
+//
+// ENUM(queued, running, done, failed)
+type JobStatus string
+
+// Job is one action-run lifecycle row. ID, CreatedAt, and UpdatedAt are
+// assigned by the store. CreatedAt and UpdatedAt are unix milliseconds. Step
+// is a human label derived from Status in v1.
+type Job struct {
+	ID        int64     `json:"id"`
+	CreatedAt int64     `json:"createdAt"`
+	UpdatedAt int64     `json:"updatedAt"`
+	Status    JobStatus `json:"status"`
+	Label     string    `json:"label"`
+	Step      string    `json:"step"`
+	ActionID  string    `json:"actionId"`
+	Target    string    `json:"target"`
+	Error     string    `json:"error,omitempty"`
+	CommandID *int64    `json:"commandId,omitempty"`
+}
+
+// stepFor returns the human step label for a status transition.
+func stepFor(status JobStatus) string {
+	switch status {
+	case JobStatusQueued:
+		return "Queued"
+	case JobStatusRunning:
+		return "Running…"
+	case JobStatusDone:
+		return "Completed"
+	case JobStatusFailed:
+		return "Failed"
+	default:
+		return ""
+	}
+}
diff --git a/internal/desktop/jobs/jobs_enum.go b/internal/desktop/jobs/jobs_enum.go
new file mode 100644
index 00000000..772955e2
--- /dev/null
+++ b/internal/desktop/jobs/jobs_enum.go
@@ -0,0 +1,92 @@
+// Code generated by go-enum DO NOT EDIT.
+// Version: v0.9.4
+
+// Built By: go install
+
+package jobs
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	// JobStatusQueued is a JobStatus of type queued.
+	JobStatusQueued JobStatus = "queued"
+	// JobStatusRunning is a JobStatus of type running.
+	JobStatusRunning JobStatus = "running"
+	// JobStatusDone is a JobStatus of type done.
+	JobStatusDone JobStatus = "done"
+	// JobStatusFailed is a JobStatus of type failed.
+	JobStatusFailed JobStatus = "failed"
+)
+
+var ErrInvalidJobStatus = fmt.Errorf("not a valid JobStatus, try [%s]", strings.Join(_JobStatusNames, ", "))
+
+var _JobStatusNames = []string{
+	string(JobStatusQueued),
+	string(JobStatusRunning),
+	string(JobStatusDone),
+	string(JobStatusFailed),
+}
+
+// JobStatusNames returns a list of possible string values of JobStatus.
+func JobStatusNames() []string {
+	tmp := make([]string, len(_JobStatusNames))
+	copy(tmp, _JobStatusNames)
+	return tmp
+}
+
+// String implements the Stringer interface.
+func (x JobStatus) String() string {
+	return string(x)
+}
+
+// IsValid provides a quick way to determine if the typed value is
+// part of the allowed enumerated values
+func (x JobStatus) IsValid() bool {
+	_, err := ParseJobStatus(string(x))
+	return err == nil
+}
+
+var _JobStatusValue = map[string]JobStatus{
+	"queued":  JobStatusQueued,
+	"running": JobStatusRunning,
+	"done":    JobStatusDone,
+	"failed":  JobStatusFailed,
+}
+
+// ParseJobStatus attempts to convert a string to a JobStatus.
+func ParseJobStatus(name string) (JobStatus, error) {
+	if x, ok := _JobStatusValue[name]; ok {
+		return x, nil
+	}
+	// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.
+	if x, ok := _JobStatusValue[strings.ToLower(name)]; ok {
+		return x, nil
+	}
+	return JobStatus(""), fmt.Errorf("%s is %w", name, ErrInvalidJobStatus)
+}
+
+// MarshalText implements the text marshaller method.
+func (x JobStatus) MarshalText() ([]byte, error) {
+	return []byte(string(x)), nil
+}
+
+// UnmarshalText implements the text unmarshaller method.
+func (x *JobStatus) UnmarshalText(text []byte) error {
+	tmp, err := ParseJobStatus(string(text))
+	if err != nil {
+		return err
+	}
+	*x = tmp
+	return nil
+}
+
+// AppendText appends the textual representation of itself to the end of b
+// (allocating a larger slice if necessary) and returns the updated slice.
+//
+// Implementations must not retain b, nor mutate any bytes within b[:len(b)].
+func (x *JobStatus) AppendText(b []byte) ([]byte, error) {
+	return append(b, x.String()...), nil
+}
diff --git a/internal/desktop/jobs/recorder.go b/internal/desktop/jobs/recorder.go
new file mode 100644
index 00000000..f1ac114d
--- /dev/null
+++ b/internal/desktop/jobs/recorder.go
@@ -0,0 +1,182 @@
+package jobs
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"github.com/colonyops/hive/internal/desktop/pipeline/pipelinedb"
+)
+
+const (
+	defaultListLimit = 200
+	maxListLimit     = 1000
+)
+
+// Recorder is the fire-and-forget write side handed to the output worker. Job
+// persistence failures are logged and never derail an action run.
+type Recorder interface {
+	// Begin creates a queued job and returns its id, or zero when persistence
+	// fails. Subsequent transitions reference this id.
+	Begin(ctx context.Context, label, actionID, target string) int64
+	// Running marks a job running and links its output_command id.
+	Running(ctx context.Context, id int64, commandID int64)
+	// Resume returns the running job linked to commandID, or zero when none can
+	// be restored. It keeps automatic retries on one lifecycle across restarts.
+	Resume(ctx context.Context, commandID int64) int64
+	// Done marks a job completed.
+	Done(ctx context.Context, id int64)
+	// Fail marks a job failed with a reason.
+	Fail(ctx context.Context, id int64, reason string)
+}
+
+// Store persists and reads jobs in the shared desktop pipeline database.
+type Store struct {
+	db   *pipelinedb.DB
+	now  func() time.Time
+	emit func(id int64)
+	log  *slog.Logger
+}
+
+// Options configures a Store. All fields are optional.
+type Options struct {
+	// Now supplies transition timestamps; defaults to time.Now.
+	Now func() time.Time
+	// Emit is called with the job id after each successful transition.
+	Emit func(id int64)
+	// Log receives persistence failures; defaults to slog.Default().
+	Log *slog.Logger
+}
+
+// NewStore builds a Store over db.
+func NewStore(db *pipelinedb.DB, opts Options) *Store {
+	s := &Store{db: db, now: opts.Now, emit: opts.Emit, log: opts.Log}
+	if s.now == nil {
+		s.now = time.Now
+	}
+	if s.log == nil {
+		s.log = slog.Default()
+	}
+	return s
+}
+
+// Begin creates a queued job. It returns zero after logging a persistence
+// failure, preserving the fire-and-forget Recorder contract.
+func (s *Store) Begin(ctx context.Context, label, actionID, target string) int64 {
+	now := s.now().UnixMilli()
+	rec, err := s.db.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: now,
+		UpdatedAt: now,
+		Status:    JobStatusQueued.String(),
+		Label:     label,
+		Step:      stepFor(JobStatusQueued),
+		ActionID:  actionID,
+		Target:    target,
+	})
+	if err != nil {
+		s.log.Warn("beginning job failed", "label", label, "action_id", actionID, "error", err)
+		return 0
+	}
+	s.emitUpdate(rec.ID)
+	return rec.ID
+}
+
+// Running advances a job to running and links its output_command id. A zero job
+// id is a safe no-op for callers whose Begin failed or whose recorder is off.
+func (s *Store) Running(ctx context.Context, id int64, commandID int64) {
+	if id == 0 {
+		return
+	}
+	if _, err := s.db.SetJobRunning(ctx, id, s.now().UnixMilli(), stepFor(JobStatusRunning), commandID); err != nil {
+		s.log.Warn("marking job running failed", "job_id", id, "command_id", commandID, "error", err)
+		return
+	}
+	s.emitUpdate(id)
+}
+
+// Resume returns the running job linked to commandID. Lookup failures are
+// logged and treated as no match so job tracking never derails command work.
+func (s *Store) Resume(ctx context.Context, commandID int64) int64 {
+	rec, found, err := s.db.FindRunningJobByCommandID(ctx, commandID)
+	if err != nil {
+		s.log.Warn("resuming job failed", "command_id", commandID, "error", err)
+		return 0
+	}
+	if !found {
+		return 0
+	}
+	return rec.ID
+}
+
+// Done advances a job to done. A zero job id is a safe no-op.
+func (s *Store) Done(ctx context.Context, id int64) {
+	s.setStatus(ctx, id, JobStatusDone, "")
+}
+
+// Fail advances a job to failed with reason. A zero job id is a safe no-op.
+func (s *Store) Fail(ctx context.Context, id int64, reason string) {
+	s.setStatus(ctx, id, JobStatusFailed, reason)
+}
+
+// List returns up to limit jobs with id < before, newest first.
+func (s *Store) List(ctx context.Context, before int64, limit int) ([]Job, error) {
+	if limit <= 0 || limit > maxListLimit {
+		limit = defaultListLimit
+	}
+	recs, err := s.db.ListJobs(ctx, before, limit)
+	if err != nil {
+		return nil, err
+	}
+	return jobsFromRecords(recs), nil
+}
+
+// ListActive returns non-terminal jobs plus terminal jobs updated within
+// window, newest first.
+func (s *Store) ListActive(ctx context.Context, window time.Duration) ([]Job, error) {
+	since := s.now().Add(-window).UnixMilli()
+	recs, err := s.db.ListActiveJobs(ctx, since)
+	if err != nil {
+		return nil, err
+	}
+	return jobsFromRecords(recs), nil
+}
+
+func (s *Store) setStatus(ctx context.Context, id int64, status JobStatus, errText string) {
+	if id == 0 {
+		return
+	}
+	if _, err := s.db.SetJobStatus(ctx, id, s.now().UnixMilli(), status.String(), stepFor(status), errText); err != nil {
+		s.log.Warn("updating job status failed", "job_id", id, "status", status, "error", err)
+		return
+	}
+	s.emitUpdate(id)
+}
+
+func (s *Store) emitUpdate(id int64) {
+	if s.emit != nil {
+		s.emit(id)
+	}
+}
+
+func jobsFromRecords(recs []pipelinedb.JobRecord) []Job {
+	out := make([]Job, 0, len(recs))
+	for _, rec := range recs {
+		out = append(out, jobFromRecord(rec))
+	}
+	return out
+}
+
+func jobFromRecord(rec pipelinedb.JobRecord) Job {
+	return Job{
+		ID:        rec.ID,
+		CreatedAt: rec.CreatedAt,
+		UpdatedAt: rec.UpdatedAt,
+		Status:    JobStatus(rec.Status),
+		Label:     rec.Label,
+		Step:      rec.Step,
+		ActionID:  rec.ActionID,
+		Target:    rec.Target,
+		Error:     rec.Error,
+		CommandID: rec.CommandID,
+	}
+}
diff --git a/internal/desktop/jobs/recorder_test.go b/internal/desktop/jobs/recorder_test.go
new file mode 100644
index 00000000..dfd3408d
--- /dev/null
+++ b/internal/desktop/jobs/recorder_test.go
@@ -0,0 +1,121 @@
+package jobs
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/colonyops/hive/internal/desktop/pipeline/pipelinedb"
+)
+
+func openJobsTestDB(t *testing.T) *pipelinedb.DB {
+	t.Helper()
+	database, err := pipelinedb.Open(t.TempDir(), pipelinedb.DefaultOpenOptions())
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = database.Close() })
+	return database
+}
+
+func TestStore_RecordsLifecycleLabelsAndEmits(t *testing.T) {
+	database := openJobsTestDB(t)
+	ctx := context.Background()
+	now := time.UnixMilli(1_000)
+	var emitted []int64
+	store := NewStore(database, Options{
+		Now:  func() time.Time { return now },
+		Emit: func(id int64) { emitted = append(emitted, id) },
+	})
+
+	id := store.Begin(ctx, "Review PR", "review", "pr-1")
+	require.Positive(t, id)
+	now = time.UnixMilli(2_000)
+	store.Running(ctx, id, 44)
+	assert.Equal(t, id, store.Resume(ctx, 44))
+	now = time.UnixMilli(3_000)
+	store.Done(ctx, id)
+	assert.Zero(t, store.Resume(ctx, 44))
+	assert.Equal(t, []int64{id, id, id}, emitted)
+
+	rows, err := store.List(ctx, 0, 10)
+	require.NoError(t, err)
+	require.Len(t, rows, 1)
+	job := rows[0]
+	assert.Equal(t, JobStatusDone, job.Status)
+	assert.Equal(t, "Completed", job.Step)
+	assert.Equal(t, int64(1_000), job.CreatedAt)
+	assert.Equal(t, int64(3_000), job.UpdatedAt)
+	require.NotNil(t, job.CommandID)
+	assert.Equal(t, int64(44), *job.CommandID)
+
+	failedID := store.Begin(ctx, "Deploy", "deploy", "pr-2")
+	store.Running(ctx, failedID, 45)
+	store.Fail(ctx, failedID, "boom")
+	rows, err = store.List(ctx, 0, 10)
+	require.NoError(t, err)
+	require.Len(t, rows, 2)
+	assert.Equal(t, JobStatusFailed, rows[0].Status)
+	assert.Equal(t, "Failed", rows[0].Step)
+	assert.Equal(t, "boom", rows[0].Error)
+	require.NotNil(t, rows[0].CommandID)
+	assert.Equal(t, int64(45), *rows[0].CommandID)
+	assert.Len(t, emitted, 6)
+}
+
+func TestStepFor(t *testing.T) {
+	tests := []struct {
+		status JobStatus
+		want   string
+	}{
+		{JobStatusQueued, "Queued"},
+		{JobStatusRunning, "Running…"},
+		{JobStatusDone, "Completed"},
+		{JobStatusFailed, "Failed"},
+	}
+	for _, test := range tests {
+		t.Run(test.status.String(), func(t *testing.T) {
+			assert.Equal(t, test.want, stepFor(test.status))
+		})
+	}
+}
+
+func TestStore_ListActiveUsesBackendClockWindow(t *testing.T) {
+	database := openJobsTestDB(t)
+	ctx := context.Background()
+	now := time.UnixMilli(10_000)
+	store := NewStore(database, Options{Now: func() time.Time { return now }})
+
+	_, err := database.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: 1, UpdatedAt: now.Add(-DefaultLingerWindow).UnixMilli(), Status: "done", Label: "Boundary",
+	})
+	require.NoError(t, err)
+	_, err = database.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: 2, UpdatedAt: now.Add(-DefaultLingerWindow - time.Millisecond).UnixMilli(), Status: "failed", Label: "Outside",
+	})
+	require.NoError(t, err)
+	queued, err := database.InsertJob(ctx, pipelinedb.JobRecord{
+		CreatedAt: 3, UpdatedAt: 1, Status: "queued", Label: "Queued",
+	})
+	require.NoError(t, err)
+
+	active, err := store.ListActive(ctx, DefaultLingerWindow)
+	require.NoError(t, err)
+	require.Len(t, active, 2)
+	assert.Equal(t, queued.ID, active[0].ID)
+	assert.Equal(t, "Boundary", active[1].Label)
+}
+
+func TestStore_BeginFailureAndZeroTransitionsAreNoOps(t *testing.T) {
+	database := openJobsTestDB(t)
+	require.NoError(t, database.Close())
+	store := NewStore(database, Options{})
+	id := store.Begin(context.Background(), "Review", "review", "pr-1")
+	assert.Zero(t, id)
+	assert.NotPanics(t, func() {
+		store.Running(context.Background(), 0, 1)
+		store.Done(context.Background(), 0)
+		store.Fail(context.Background(), 0, "ignored")
+	})
+}
diff --git a/internal/desktop/pipeline/actions/seed.go b/internal/desktop/pipeline/actions/seed.go
index d4009fb1..56d6b9ca 100644
--- a/internal/desktop/pipeline/actions/seed.go
+++ b/internal/desktop/pipeline/actions/seed.go
@@ -16,9 +16,9 @@ actions:
     applies_to: [pr]
     repo_template: "https://github.com/{{ .Payload.repo }}.git"
     prompt_template: |
-      Review pull request {{ .Payload.url }}: {{ .Payload.title }}
+      Review pull request {{ .Payload.title }}
 
-      {{ .Payload.body }}
+      {{ .Payload.url }}
   - id: start-implementation
     label: Start implementation
     type: launch-session
@@ -26,7 +26,9 @@ actions:
     applies_to: [issue]
     repo_template: "https://github.com/{{ .Payload.repo }}.git"
     prompt_template: |
-      Implement issue {{ .Payload.url }}: {{ .Payload.title }}
+      Work on {{ .Payload.title }}
+
+      {{ .Payload.url }}
 
       {{ .Payload.body }}
 `
diff --git a/internal/desktop/pipeline/output_worker.go b/internal/desktop/pipeline/output_worker.go
index c3d29509..07ba5b7e 100644
--- a/internal/desktop/pipeline/output_worker.go
+++ b/internal/desktop/pipeline/output_worker.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/colonyops/hive/internal/desktop/activity"
+	"github.com/colonyops/hive/internal/desktop/jobs"
 	"github.com/colonyops/hive/internal/desktop/pipeline/actions"
 	"github.com/colonyops/hive/internal/desktop/pipeline/pipelinedb"
 	"github.com/rs/zerolog"
@@ -58,13 +59,14 @@ type OutputCommandStore interface {
 	RetryOutputCommand(context.Context, int64, string, ...string) error
 }
 type Worker struct {
-	db       OutputCommandStore
-	actions  ActionLister
-	dispatch *Dispatcher
-	interval time.Duration
-	batch    int
-	logger   zerolog.Logger
-	recorder activity.Recorder
+	db          OutputCommandStore
+	actions     ActionLister
+	dispatch    *Dispatcher
+	interval    time.Duration
+	batch       int
+	logger      zerolog.Logger
+	recorder    activity.Recorder
+	jobRecorder jobs.Recorder
 
 	runMu    sync.Mutex
 	stopOnce sync.Once
@@ -72,7 +74,11 @@ type Worker struct {
 }
 
 func NewWorker(db OutputCommandStore, as ActionLister, d *Dispatcher, interval time.Duration, logger zerolog.Logger) *Worker {
-	return &Worker{db: db, actions: as, dispatch: d, interval: interval, batch: DefaultOutputWorkerBatch, logger: logger, stop: make(chan struct{})}
+	return &Worker{
+		db: db, actions: as, dispatch: d, interval: interval,
+		batch: DefaultOutputWorkerBatch, logger: logger,
+		stop: make(chan struct{}),
+	}
 }
 
 // SetRecorder attaches an activity recorder so automatic and manual action
@@ -80,6 +86,10 @@ func NewWorker(db OutputCommandStore, as ActionLister, d *Dispatcher, interval t
 // a nil recorder (the default) records nothing. Set once at wiring time.
 func (w *Worker) SetRecorder(r activity.Recorder) { w.recorder = r }
 
+// SetJobRecorder attaches a jobs recorder so manual and automatic action runs
+// surface as live jobs. A nil recorder, the default, records nothing.
+func (w *Worker) SetJobRecorder(r jobs.Recorder) { w.jobRecorder = r }
+
 // record forwards an activity event when a recorder is attached; nil is a
 // no-op, and the recorder itself logs and swallows write failures.
 func (w *Worker) record(ctx context.Context, e activity.Event) {
@@ -88,6 +98,42 @@ func (w *Worker) record(ctx context.Context, e activity.Event) {
 	}
 }
 
+func (w *Worker) jobBegin(ctx context.Context, label, actionID, target string) int64 {
+	if w.jobRecorder == nil {
+		return 0
+	}
+	return w.jobRecorder.Begin(ctx, label, actionID, target)
+}
+
+func (w *Worker) jobRunning(ctx context.Context, id, commandID int64) {
+	if w.jobRecorder != nil && id != 0 {
+		w.jobRecorder.Running(ctx, id, commandID)
+	}
+}
+
+func (w *Worker) jobResume(ctx context.Context, commandID int64) int64 {
+	if w.jobRecorder == nil {
+		return 0
+	}
+	return w.jobRecorder.Resume(ctx, commandID)
+}
+
+func (w *Worker) jobDone(ctx context.Context, id int64) {
+	if w.jobRecorder != nil && id != 0 {
+		w.jobRecorder.Done(ctx, id)
+	}
+}
+
+func (w *Worker) jobFail(ctx context.Context, id int64, reason string) {
+	if w.jobRecorder != nil && id != 0 {
+		w.jobRecorder.Fail(ctx, id, reason)
+	}
+}
+
+func (w *Worker) jobLogger(id int64, actionID string) zerolog.Logger {
+	return w.logger.With().Int64("job_id", id).Str("action_id", actionID).Logger()
+}
+
 func (w *Worker) Start() {
 	go func() {
 		ticker := time.NewTicker(w.interval)
@@ -113,22 +159,40 @@ func (w *Worker) Confirm(ctx context.Context, actionID, key string, payload []by
 	if !created {
 		return ActionRunView{}, fmt.Errorf("action %q has already run for %q", actionID, key)
 	}
+
 	action, ok := w.actions.Get(actionID)
+	label := actionID
+	if ok {
+		label = actionLabel(action)
+	}
+	jobID := w.jobBegin(ctx, label, actionID, key)
+	logger := w.jobLogger(jobID, actionID)
+	logger.Debug().Msg("output worker: job queued")
+
 	if !ok {
 		err = fmt.Errorf("unknown action %q", actionID)
 		if markErr := w.db.MarkOutputCommandFailed(ctx, row.ID, err.Error()); markErr != nil {
+			logger.Error().Err(markErr).Msg("output worker: marking command failed")
 			return ActionRunView{}, markErr
 		}
+		w.jobFail(ctx, jobID, err.Error())
+		logger.Debug().Err(err).Msg("output worker: job failed")
 		return w.view(ctx, row.ID), err
 	}
-	result, err := w.execute(ctx, row, action, input)
+
+	w.jobRunning(ctx, jobID, row.ID)
+	logger.Debug().Int64("command_id", row.ID).Msg("output worker: job running")
+	result, err := w.execute(ctx, row, action, input, logger)
 	if err != nil {
 		// A detail-pane confirmation is an explicit, one-shot attempted side
 		// effect. Persist its diagnostics and make it terminal rather than
 		// retrying later without the interactive input that authorized it.
 		if markErr := w.db.MarkOutputCommandFailed(ctx, row.ID, err.Error(), boundExecutionStream(result.Log.Stdout), boundExecutionStream(result.Log.Stderr)); markErr != nil {
+			logger.Error().Err(markErr).Msg("output worker: marking command failed")
 			return ActionRunView{}, markErr
 		}
+		w.jobFail(ctx, jobID, err.Error())
+		logger.Debug().Err(err).Msg("output worker: job failed")
 		view := w.view(ctx, row.ID)
 		if result.Attempted {
 			// The side effect was dispatched and failed. Return its durable
@@ -138,8 +202,11 @@ func (w *Worker) Confirm(ctx context.Context, actionID, key string, payload []by
 		return view, err
 	}
 	if err = w.done(ctx, row.ID, result); err != nil {
+		logger.Error().Err(err).Msg("output worker: marking command done failed")
 		return ActionRunView{}, err
 	}
+	w.jobDone(ctx, jobID)
+	logger.Debug().Msg("output worker: job done")
 	// A launch-session run is recorded as a session event by the launcher.
 	if action.Type != ActionTypeLaunchSession {
 		w.record(ctx, activity.ActionRun(actionLabel(action), ""))
@@ -173,18 +240,39 @@ func (w *Worker) Tick(ctx context.Context) {
 
 func (w *Worker) process(ctx context.Context, row pipelinedb.OutputCommand) {
 	a, ok := w.actions.Get(row.ActionID)
+	label := row.ActionID
+	if ok {
+		label = actionLabel(a)
+	}
+	jobID := w.jobResume(ctx, row.ID)
+	resumed := jobID != 0
+	if !resumed {
+		jobID = w.jobBegin(ctx, label, row.ActionID, row.Key)
+	}
+	logger := w.jobLogger(jobID, row.ActionID)
+	if !resumed {
+		logger.Debug().Msg("output worker: job queued")
+	}
+
+	if !resumed {
+		w.jobRunning(ctx, jobID, row.ID)
+		logger.Debug().Int64("command_id", row.ID).Msg("output worker: job running")
+	}
 	if !ok {
-		w.fail(ctx, row, ExecutionResult{}, fmt.Errorf("unknown action %q", row.ActionID))
+		w.fail(ctx, row, ExecutionResult{}, fmt.Errorf("unknown action %q", row.ActionID), jobID, logger)
 		return
 	}
-	result, err := w.execute(ctx, row, a, ActionInvocationInput{})
+	result, err := w.execute(ctx, row, a, ActionInvocationInput{}, logger)
 	if err != nil {
-		w.fail(ctx, row, result, err)
+		w.fail(ctx, row, result, err, jobID, logger)
 		return
 	}
 	if err := w.done(ctx, row.ID, result); err != nil {
-		w.logger.Error().Err(err).Msg("output worker: marking command done failed")
+		logger.Error().Err(err).Msg("output worker: marking command done failed")
+		return
 	}
+	w.jobDone(ctx, jobID)
+	logger.Debug().Msg("output worker: job done")
 	// This is the automatic path (process only executes when the action
 	// auto-applies). A launch-session run is recorded by the launcher instead.
 	if a.Type != ActionTypeLaunchSession {
@@ -201,19 +289,36 @@ func actionLabel(action actions.Action) string {
 	return action.ID
 }
 
-func (w *Worker) execute(ctx context.Context, row pipelinedb.OutputCommand, a actions.Action, input ActionInvocationInput) (ExecutionResult, error) {
+func (w *Worker) execute(
+	ctx context.Context,
+	row pipelinedb.OutputCommand,
+	a actions.Action,
+	input ActionInvocationInput,
+	logger zerolog.Logger,
+) (ExecutionResult, error) {
 	var payload map[string]any
 	if err := json.Unmarshal(row.Payload, &payload); err != nil {
+		logger.Warn().Err(err).Msg("output worker: decoding command payload failed")
 		return ExecutionResult{}, fmt.Errorf("decode payload: %w", err)
 	}
 	return w.dispatch.Execute(ctx, a, OutputData{Key: row.Key, Payload: payload, Raw: json.RawMessage(row.Payload)}, input)
 }
 
-func (w *Worker) fail(ctx context.Context, row pipelinedb.OutputCommand, result ExecutionResult, execErr error) {
+func (w *Worker) fail(
+	ctx context.Context,
+	row pipelinedb.OutputCommand,
+	result ExecutionResult,
+	execErr error,
+	jobID int64,
+	logger zerolog.Logger,
+) {
 	if row.Attempts+1 >= MaxOutputCommandAttempts {
 		if err := w.db.MarkOutputCommandFailed(ctx, row.ID, execErr.Error(), boundExecutionStream(result.Log.Stdout), boundExecutionStream(result.Log.Stderr)); err != nil {
-			w.logger.Error().Err(err).Msg("output worker: mark failed")
+			logger.Error().Err(err).Msg("output worker: mark failed")
+			return
 		}
+		w.jobFail(ctx, jobID, execErr.Error())
+		logger.Debug().Err(execErr).Msg("output worker: job failed")
 		// Only the terminal failure reaches the Activity view; retries stay in
 		// the logs so a flaky action doesn't spam the feed.
 		label := row.ActionID
@@ -224,8 +329,10 @@ func (w *Worker) fail(ctx context.Context, row pipelinedb.OutputCommand, result
 		return
 	}
 	if err := w.db.RetryOutputCommand(ctx, row.ID, execErr.Error(), boundExecutionStream(result.Log.Stdout), boundExecutionStream(result.Log.Stderr)); err != nil {
-		w.logger.Error().Err(err).Msg("output worker: retry")
+		logger.Error().Err(err).Msg("output worker: retry")
+		return
 	}
+	logger.Debug().Err(execErr).Msg("output worker: command scheduled for retry")
 }
 
 func (w *Worker) view(ctx context.Context, id int64) ActionRunView {
diff --git a/internal/desktop/pipeline/output_worker_test.go b/internal/desktop/pipeline/output_worker_test.go
index 7c087645..08a5732d 100644
--- a/internal/desktop/pipeline/output_worker_test.go
+++ b/internal/desktop/pipeline/output_worker_test.go
@@ -59,6 +59,48 @@ type fakeExecutor struct {
 	result ExecutionResult
 }
 
+type fakeJobRecorder struct {
+	calls     []string
+	label     string
+	actionID  string
+	target    string
+	commandID int64
+	active    bool
+	reason    string
+}
+
+func (f *fakeJobRecorder) Begin(_ context.Context, label, actionID, target string) int64 {
+	f.calls = append(f.calls, "Begin")
+	f.label = label
+	f.actionID = actionID
+	f.target = target
+	return 42
+}
+
+func (f *fakeJobRecorder) Running(_ context.Context, _ int64, commandID int64) {
+	f.calls = append(f.calls, "Running")
+	f.commandID = commandID
+	f.active = true
+}
+
+func (f *fakeJobRecorder) Resume(_ context.Context, commandID int64) int64 {
+	if f.active && f.commandID == commandID {
+		return 42
+	}
+	return 0
+}
+
+func (f *fakeJobRecorder) Done(_ context.Context, _ int64) {
+	f.calls = append(f.calls, "Done")
+	f.active = false
+}
+
+func (f *fakeJobRecorder) Fail(_ context.Context, _ int64, reason string) {
+	f.calls = append(f.calls, "Fail")
+	f.active = false
+	f.reason = reason
+}
+
 func (f *fakeExecutor) Execute(_ context.Context, _ actions.Action, data OutputData, _ ActionInvocationInput) (ExecutionResult, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -145,6 +187,43 @@ func TestWorker_ConfirmCannotReplayAlreadyCompletedDeployedFlowCommand(t *testin
 	assert.Error(t, err, "completed actions remain deduped")
 }
 
+func TestWorker_ConfirmRecordsJobLifecycleWithoutReplay(t *testing.T) {
+	t.Parallel()
+	db := openTestPipelineDB(t)
+	exec := &fakeExecutor{}
+	recorder := &fakeJobRecorder{}
+	worker := NewWorker(db, fakeActionLister{"review-action": launchSessionAction("review-action", false)},
+		NewDispatcher(map[string]Executor{"launch-session": exec}), 0, zerolog.Nop())
+	worker.SetJobRecorder(recorder)
+
+	_, err := worker.Confirm(t.Context(), "review-action", "item-1", []byte(`{"title":"Fix bug"}`), ActionInvocationInput{})
+	require.NoError(t, err)
+	assert.Equal(t, []string{"Begin", "Running", "Done"}, recorder.calls)
+	assert.Equal(t, "Test action", recorder.label)
+	assert.Equal(t, "review-action", recorder.actionID)
+	assert.Equal(t, "item-1", recorder.target)
+	assert.Positive(t, recorder.commandID)
+
+	recorder.calls = nil
+	_, err = worker.Confirm(t.Context(), "review-action", "item-1", []byte(`{}`), ActionInvocationInput{})
+	require.Error(t, err)
+	assert.Empty(t, recorder.calls, "idempotent replay must not create a phantom job")
+}
+
+func TestWorker_ConfirmUnknownActionRecordsQueuedFailure(t *testing.T) {
+	t.Parallel()
+	db := openTestPipelineDB(t)
+	recorder := &fakeJobRecorder{}
+	worker := NewWorker(db, fakeActionLister{}, NewDispatcher(nil), 0, zerolog.Nop())
+	worker.SetJobRecorder(recorder)
+
+	_, err := worker.Confirm(t.Context(), "missing", "item-1", []byte(`{}`), ActionInvocationInput{})
+	require.Error(t, err)
+	assert.Equal(t, []string{"Begin", "Fail"}, recorder.calls)
+	assert.Equal(t, "missing", recorder.label)
+	assert.Contains(t, recorder.reason, "unknown action")
+}
+
 func TestWorker_ConfirmCreatesCommandWhenNoActionNodeProducedOne(t *testing.T) {
 	t.Parallel()
 	db := openTestPipelineDB(t)
@@ -208,14 +287,47 @@ func TestWorker_UnknownActionRecordsRetryableError(t *testing.T) {
 	enqueueTestCommand(t, db, "does-not-exist", "item-1", `{}`)
 
 	exec := &fakeExecutor{}
+	recorder := &fakeJobRecorder{}
 	worker := NewWorker(db, fakeActionLister{}, NewDispatcher(map[string]Executor{"launch-session": exec}), 0, zerolog.Nop())
+	worker.SetJobRecorder(recorder)
 	worker.Tick(t.Context())
 	assert.Equal(t, 0, exec.callCount())
+	assert.Equal(t, []string{"Begin", "Running"}, recorder.calls)
 	rows, err := db.ListRunnableOutputCommands(t.Context(), 10)
 	require.NoError(t, err)
 	require.Len(t, rows, 1)
 	assert.Equal(t, int64(1), rows[0].Attempts)
 	assert.Contains(t, rows[0].LastError.String, "unknown action")
+
+	for range MaxOutputCommandAttempts - 1 {
+		worker.Tick(t.Context())
+	}
+	assert.Equal(t, []string{"Begin", "Running", "Fail"}, recorder.calls)
+}
+
+func TestWorker_FailingExecutor_KeepsOneRunningJobUntilTerminalFailure(t *testing.T) {
+	t.Parallel()
+	db := openTestPipelineDB(t)
+	enqueueTestCommand(t, db, "spawn-review", "item-1", `{"title":"Fix bug"}`)
+
+	exec := &fakeExecutor{err: fmt.Errorf("boom")}
+	recorder := &fakeJobRecorder{}
+	worker := NewWorker(db, fakeActionLister{"spawn-review": launchSessionAction("spawn-review", true)},
+		NewDispatcher(map[string]Executor{"launch-session": exec}), 0, zerolog.Nop())
+	worker.SetJobRecorder(recorder)
+
+	for attempt := range MaxOutputCommandAttempts - 1 {
+		worker.Tick(t.Context())
+		assert.Equal(t, []string{"Begin", "Running"}, recorder.calls, "retryable failures leave the existing job running")
+		if attempt == 0 {
+			worker = NewWorker(db, fakeActionLister{"spawn-review": launchSessionAction("spawn-review", true)},
+				NewDispatcher(map[string]Executor{"launch-session": exec}), 0, zerolog.Nop())
+			worker.SetJobRecorder(recorder)
+		}
+	}
+	worker.Tick(t.Context())
+	assert.Equal(t, []string{"Begin", "Running", "Fail"}, recorder.calls)
+	assert.Equal(t, "boom", recorder.reason)
 }
 
 func TestWorker_FailingExecutor_RetriesThenMarksFailed(t *testing.T) {
@@ -256,13 +368,17 @@ func TestWorker_FailingExecutor_RetriesThenMarksFailed(t *testing.T) {
 func TestWorker_ConfirmFailureReturnsPersistedDiagnostics(t *testing.T) {
 	db := openTestPipelineDB(t)
 	exec := &fakeExecutor{err: fmt.Errorf("boom"), result: ExecutionResult{Attempted: true, Log: ExecutionLog{Stdout: "partial output", Stderr: "failure output"}}}
+	recorder := &fakeJobRecorder{}
 	worker := NewWorker(db, fakeActionLister{"review-action": launchSessionAction("review-action", false)}, NewDispatcher(map[string]Executor{"launch-session": exec}), 0, zerolog.Nop())
+	worker.SetJobRecorder(recorder)
 	view, err := worker.Confirm(t.Context(), "review-action", "item-1", []byte(`{"title":"Fix bug"}`), ActionInvocationInput{})
 	require.NoError(t, err, "an attempted side-effect failure is returned as a persisted view")
 	assert.Equal(t, "failed", view.Status)
 	assert.Equal(t, "boom", view.Error)
 	assert.Equal(t, "partial output", view.Stdout)
 	assert.Equal(t, "failure output", view.Stderr)
+	assert.Equal(t, []string{"Begin", "Running", "Fail"}, recorder.calls)
+	assert.Equal(t, "boom", recorder.reason)
 }
 
 func TestWorker_DoesNotRetryInterruptedInteractiveCommandAfterReopen(t *testing.T) {
diff --git a/internal/desktop/pipeline/pipelinedb/dbext_test.go b/internal/desktop/pipeline/pipelinedb/dbext_test.go
index 6df7d363..7e0330c1 100644
--- a/internal/desktop/pipeline/pipelinedb/dbext_test.go
+++ b/internal/desktop/pipeline/pipelinedb/dbext_test.go
@@ -116,9 +116,15 @@ func TestOpen_RecoversInterruptedRunningCommandWithoutRetry(t *testing.T) {
 	first, err := Open(dir, DefaultOpenOptions())
 	require.NoError(t, err)
 	enqueueTestCommand(t, first, "review", "item-1")
-	_, created, err := first.ConfirmOutputCommand(ctx, "review", "item-1", []byte(`{}`))
+	command, created, err := first.ConfirmOutputCommand(ctx, "review", "item-1", []byte(`{}`))
 	require.NoError(t, err)
 	require.True(t, created)
+	job, err := first.InsertJob(ctx, JobRecord{CreatedAt: 1, UpdatedAt: 1, Status: "queued", Label: "Review"})
+	require.NoError(t, err)
+	_, err = first.SetJobRunning(ctx, job.ID, 2, "Running…", command.ID)
+	require.NoError(t, err)
+	_, err = first.InsertJob(ctx, JobRecord{CreatedAt: 3, UpdatedAt: 3, Status: "queued", Label: "Interrupted before link"})
+	require.NoError(t, err)
 	require.NoError(t, first.Close())
 
 	reopened, err := Open(dir, DefaultOpenOptions())
@@ -132,6 +138,14 @@ func TestOpen_RecoversInterruptedRunningCommandWithoutRetry(t *testing.T) {
 	rows, err := reopened.ListRunnableOutputCommands(ctx, 10)
 	require.NoError(t, err)
 	assert.Empty(t, rows)
+	jobs, err := reopened.ListJobs(ctx, 0, 10)
+	require.NoError(t, err)
+	require.Len(t, jobs, 2)
+	for _, job := range jobs {
+		assert.Equal(t, "failed", job.Status)
+		assert.Equal(t, "Failed", job.Step)
+		assert.Contains(t, job.Error, "interrupted")
+	}
 }
 
 func TestOpen_Idempotent(t *testing.T) {
diff --git a/internal/desktop/pipeline/pipelinedb/jobs.go b/internal/desktop/pipeline/pipelinedb/jobs.go
new file mode 100644
index 00000000..d5510ace
--- /dev/null
+++ b/internal/desktop/pipeline/pipelinedb/jobs.go
@@ -0,0 +1,163 @@
+package pipelinedb
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"math"
+)
+
+// JobRecord is the storage shape of one job row. Status and step stay plain
+// strings at this layer; the jobs package owns the typed status and converts at
+// its boundary. CommandID is nil until the job is linked to an output_command.
+type JobRecord struct {
+	ID        int64  `json:"id"`
+	CreatedAt int64  `json:"createdAt"`
+	UpdatedAt int64  `json:"updatedAt"`
+	Status    string `json:"status"`
+	Label     string `json:"label"`
+	Step      string `json:"step"`
+	ActionID  string `json:"actionId"`
+	Target    string `json:"target"`
+	Error     string `json:"error"`
+	CommandID *int64 `json:"commandId,omitempty"`
+}
+
+// InsertJob persists one job and returns the stored row with its assigned id.
+func (db *DB) InsertJob(ctx context.Context, rec JobRecord) (JobRecord, error) {
+	row, err := db.queries.InsertJob(ctx, InsertJobParams{
+		CreatedAt: rec.CreatedAt,
+		UpdatedAt: rec.UpdatedAt,
+		Status:    rec.Status,
+		Label:     rec.Label,
+		Step:      rec.Step,
+		ActionID:  rec.ActionID,
+		Target:    rec.Target,
+		Error:     rec.Error,
+		CommandID: nullableInt64(rec.CommandID),
+	})
+	if err != nil {
+		return JobRecord{}, fmt.Errorf("inserting job %q: %w", rec.Label, err)
+	}
+	return jobRecordFromRow(row), nil
+}
+
+// SetJobRunning advances a job to running and links its output_command. This is
+// the only job update that writes command_id.
+func (db *DB) SetJobRunning(
+	ctx context.Context,
+	id int64,
+	updatedAt int64,
+	step string,
+	commandID int64,
+) (JobRecord, error) {
+	row, err := db.queries.SetJobRunning(ctx, SetJobRunningParams{
+		UpdatedAt: updatedAt,
+		Status:    "running",
+		Step:      step,
+		CommandID: sql.NullInt64{Int64: commandID, Valid: true},
+		ID:        id,
+	})
+	if err != nil {
+		return JobRecord{}, fmt.Errorf("setting job %d running: %w", id, err)
+	}
+	return jobRecordFromRow(row), nil
+}
+
+// SetJobStatus advances a job's status, step, and error without changing its
+// command_id link.
+func (db *DB) SetJobStatus(
+	ctx context.Context,
+	id int64,
+	updatedAt int64,
+	status string,
+	step string,
+	errText string,
+) (JobRecord, error) {
+	row, err := db.queries.SetJobStatus(ctx, SetJobStatusParams{
+		UpdatedAt: updatedAt,
+		Status:    status,
+		Step:      step,
+		Error:     errText,
+		ID:        id,
+	})
+	if err != nil {
+		return JobRecord{}, fmt.Errorf("setting job %d status to %q: %w", id, status, err)
+	}
+	return jobRecordFromRow(row), nil
+}
+
+// FindRunningJobByCommandID returns the running job linked to commandID. The
+// boolean is false when no such job exists.
+func (db *DB) FindRunningJobByCommandID(ctx context.Context, commandID int64) (JobRecord, bool, error) {
+	row, err := db.queries.FindRunningJobByCommandID(ctx, sql.NullInt64{Int64: commandID, Valid: true})
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return JobRecord{}, false, nil
+		}
+		return JobRecord{}, false, fmt.Errorf("finding running job for command %d: %w", commandID, err)
+	}
+	return jobRecordFromRow(row), true, nil
+}
+
+// ListJobs returns up to limit jobs with id < before, newest first. Pass before
+// <= 0 to start from the most recent job.
+func (db *DB) ListJobs(ctx context.Context, before int64, limit int) ([]JobRecord, error) {
+	if before <= 0 {
+		before = math.MaxInt64
+	}
+	rows, err := db.queries.ListJobs(ctx, ListJobsParams{
+		ID:    before,
+		Limit: int64(limit),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("listing jobs: %w", err)
+	}
+	return jobRecordsFromRows(rows), nil
+}
+
+// ListActiveJobs returns non-terminal jobs and terminal jobs updated at or
+// after since, newest first.
+func (db *DB) ListActiveJobs(ctx context.Context, since int64) ([]JobRecord, error) {
+	rows, err := db.queries.ListActiveJobs(ctx, since)
+	if err != nil {
+		return nil, fmt.Errorf("listing active jobs: %w", err)
+	}
+	return jobRecordsFromRows(rows), nil
+}
+
+func jobRecordsFromRows(rows []Job) []JobRecord {
+	out := make([]JobRecord, 0, len(rows))
+	for _, row := range rows {
+		out = append(out, jobRecordFromRow(row))
+	}
+	return out
+}
+
+func jobRecordFromRow(row Job) JobRecord {
+	var commandID *int64
+	if row.CommandID.Valid {
+		value := row.CommandID.Int64
+		commandID = &value
+	}
+	return JobRecord{
+		ID:        row.ID,
+		CreatedAt: row.CreatedAt,
+		UpdatedAt: row.UpdatedAt,
+		Status:    row.Status,
+		Label:     row.Label,
+		Step:      row.Step,
+		ActionID:  row.ActionID,
+		Target:    row.Target,
+		Error:     row.Error,
+		CommandID: commandID,
+	}
+}
+
+func nullableInt64(value *int64) sql.NullInt64 {
+	if value == nil {
+		return sql.NullInt64{}
+	}
+	return sql.NullInt64{Int64: *value, Valid: true}
+}
diff --git a/internal/desktop/pipeline/pipelinedb/jobs_test.go b/internal/desktop/pipeline/pipelinedb/jobs_test.go
new file mode 100644
index 00000000..0ba30b68
--- /dev/null
+++ b/internal/desktop/pipeline/pipelinedb/jobs_test.go
@@ -0,0 +1,101 @@
+package pipelinedb
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestJobs_LifecyclePagingAndActiveWindow(t *testing.T) {
+	database := openTestDB(t)
+	ctx := context.Background()
+
+	first, err := database.InsertJob(ctx, JobRecord{
+		CreatedAt: 100, UpdatedAt: 100, Status: "queued", Label: "First",
+		Step: "Queued", ActionID: "review", Target: "item-1",
+	})
+	require.NoError(t, err)
+	assert.Nil(t, first.CommandID)
+
+	running, err := database.SetJobRunning(ctx, first.ID, 200, "Running…", 41)
+	require.NoError(t, err)
+	require.NotNil(t, running.CommandID)
+	assert.Equal(t, int64(41), *running.CommandID)
+	assert.Equal(t, "running", running.Status)
+
+	done, err := database.SetJobStatus(ctx, first.ID, 300, "done", "Completed", "")
+	require.NoError(t, err)
+	require.NotNil(t, done.CommandID)
+	assert.Equal(t, int64(41), *done.CommandID, "terminal transition must preserve command_id")
+
+	failed, err := database.InsertJob(ctx, JobRecord{
+		CreatedAt: 400, UpdatedAt: 499, Status: "failed", Label: "Failed",
+		Step: "Failed", ActionID: "review", Target: "item-2", Error: "boom",
+	})
+	require.NoError(t, err)
+	queued, err := database.InsertJob(ctx, JobRecord{
+		CreatedAt: 500, UpdatedAt: 1, Status: "queued", Label: "Queued", Step: "Queued",
+	})
+	require.NoError(t, err)
+
+	page, err := database.ListJobs(ctx, 0, 2)
+	require.NoError(t, err)
+	require.Len(t, page, 2)
+	assert.Equal(t, []int64{queued.ID, failed.ID}, []int64{page[0].ID, page[1].ID})
+	older, err := database.ListJobs(ctx, page[1].ID, 2)
+	require.NoError(t, err)
+	require.Len(t, older, 1)
+	assert.Equal(t, first.ID, older[0].ID)
+
+	active, err := database.ListActiveJobs(ctx, 500)
+	require.NoError(t, err)
+	require.Len(t, active, 1)
+	assert.Equal(t, queued.ID, active[0].ID, "terminal row just outside the boundary is excluded")
+	active, err = database.ListActiveJobs(ctx, 499)
+	require.NoError(t, err)
+	require.Len(t, active, 2)
+	assert.Equal(t, []int64{queued.ID, failed.ID}, []int64{active[0].ID, active[1].ID}, "boundary is inclusive")
+
+	_, found, err := database.FindRunningJobByCommandID(ctx, 41)
+	require.NoError(t, err)
+	assert.False(t, found, "terminal jobs are not resumable")
+
+	second, err := database.InsertJob(ctx, JobRecord{CreatedAt: 600, UpdatedAt: 600, Status: "queued", Label: "Second"})
+	require.NoError(t, err)
+	_, err = database.SetJobRunning(ctx, second.ID, 601, "Running…", 42)
+	require.NoError(t, err)
+	resumed, found, err := database.FindRunningJobByCommandID(ctx, 42)
+	require.NoError(t, err)
+	require.True(t, found)
+	assert.Equal(t, second.ID, resumed.ID)
+}
+
+func TestJobs_ActiveJobPersistsAcrossReopen(t *testing.T) {
+	dir := t.TempDir()
+	ctx := context.Background()
+	database, err := Open(dir, DefaultOpenOptions())
+	require.NoError(t, err)
+	_, err = database.Conn().ExecContext(ctx, `
+		INSERT INTO output_command (action_id, key, payload, status, created_at)
+		VALUES ('review', 'item-1', X'7B7D', 'pending', 1)`)
+	require.NoError(t, err)
+	job, err := database.InsertJob(ctx, JobRecord{
+		CreatedAt: 100, UpdatedAt: 100, Status: "queued", Label: "Persisted", Step: "Queued",
+	})
+	require.NoError(t, err)
+	_, err = database.SetJobRunning(ctx, job.ID, 101, "Running…", 1)
+	require.NoError(t, err)
+	require.NoError(t, database.Close())
+
+	reopened, err := Open(dir, DefaultOpenOptions())
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, reopened.Close()) })
+	active, err := reopened.ListActiveJobs(ctx, 1_000)
+	require.NoError(t, err)
+	require.Len(t, active, 1)
+	assert.Equal(t, job.ID, active[0].ID)
+	require.NotNil(t, active[0].CommandID)
+	assert.Equal(t, int64(1), *active[0].CommandID)
+}
diff --git a/internal/desktop/pipeline/pipelinedb/migrations/0010_job.up.sql b/internal/desktop/pipeline/pipelinedb/migrations/0010_job.up.sql
new file mode 100644
index 00000000..c641cb42
--- /dev/null
+++ b/internal/desktop/pipeline/pipelinedb/migrations/0010_job.up.sql
@@ -0,0 +1,23 @@
+-- job is the desktop's live action-run lifecycle, surfaced by the titlebar
+-- spinner chip and its popover: queued -> running -> done|failed. Unlike
+-- activity_event (a terminal audit log), a job row is written at every
+-- transition so the frontend can show in-flight work. status stays plain TEXT
+-- (the jobs package owns the typed JobStatus and converts at its boundary).
+-- created_at/updated_at are unix MILLISECONDS (like activity_event) so they
+-- survive the int64->JS number boundary in the Wails bindings. command_id is a
+-- nullable link to the originating output_command row so the popover can
+-- deep-link to the existing ActionRun detail. step is a human label derived per
+-- status transition in v1; the column exists so executor sub-steps can be added
+-- later without a schema change.
+CREATE TABLE job (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at  INTEGER NOT NULL,
+    updated_at  INTEGER NOT NULL,
+    status      TEXT NOT NULL,
+    label       TEXT NOT NULL DEFAULT '',
+    step        TEXT NOT NULL DEFAULT '',
+    action_id   TEXT NOT NULL DEFAULT '',
+    target      TEXT NOT NULL DEFAULT '',
+    error       TEXT NOT NULL DEFAULT '',
+    command_id  INTEGER
+) STRICT;
diff --git a/internal/desktop/pipeline/pipelinedb/models.go b/internal/desktop/pipeline/pipelinedb/models.go
index 87f68841..70135c8d 100644
--- a/internal/desktop/pipeline/pipelinedb/models.go
+++ b/internal/desktop/pipeline/pipelinedb/models.go
@@ -43,6 +43,19 @@ type FeedItem struct {
 	SnapshotID  string `json:"snapshot_id"`
 }
 
+type Job struct {
+	ID        int64         `json:"id"`
+	CreatedAt int64         `json:"created_at"`
+	UpdatedAt int64         `json:"updated_at"`
+	Status    string        `json:"status"`
+	Label     string        `json:"label"`
+	Step      string        `json:"step"`
+	ActionID  string        `json:"action_id"`
+	Target    string        `json:"target"`
+	Error     string        `json:"error"`
+	CommandID sql.NullInt64 `json:"command_id"`
+}
+
 type NodeRun struct {
 	FlowID    string         `json:"flow_id"`
 	NodeID    string         `json:"node_id"`
diff --git a/internal/desktop/pipeline/pipelinedb/output_command.go b/internal/desktop/pipeline/pipelinedb/output_command.go
index dff5ed93..550c283e 100644
--- a/internal/desktop/pipeline/pipelinedb/output_command.go
+++ b/internal/desktop/pipeline/pipelinedb/output_command.go
@@ -92,14 +92,34 @@ func wrap(msg string, err error) error {
 	return fmt.Errorf("%s: %w", msg, err)
 }
 
-// RecoverInterruptedOutputCommands makes a stale explicit invocation terminal.
-// A running command may already have performed its side effect before a crash,
-// so retrying it in the background would be unauthorized and unsafe.
+const interruptedOutputCommandError = "interrupted: application stopped while action was running"
+
+// RecoverInterruptedOutputCommands makes stale explicit invocations and their
+// linked jobs terminal. It also fails unlinked queued jobs, which in v1 can only
+// be left by a crash between Begin and Running. A running command may already
+// have performed its side effect before a crash, so retrying it in the
+// background would be unauthorized and unsafe.
 func (db *DB) RecoverInterruptedOutputCommands(ctx context.Context) error {
-	_, err := db.conn.ExecContext(ctx, `
+	tx, err := db.conn.BeginTx(ctx, nil)
+	if err != nil {
+		return wrap("starting interrupted output command recovery", err)
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	if _, err = tx.ExecContext(ctx, `
+		UPDATE job
+		SET status = 'failed', step = 'Failed', error = ?, updated_at = ?
+		WHERE (status = 'queued' AND command_id IS NULL)
+			OR (status = 'running'
+				AND command_id IN (SELECT id FROM output_command WHERE status = 'running'))`,
+		interruptedOutputCommandError, time.Now().UnixMilli()); err != nil {
+		return wrap("recovering interrupted jobs", err)
+	}
+	if _, err = tx.ExecContext(ctx, `
 		UPDATE output_command
-		SET status = 'failed', attempts = attempts + 1,
-			last_error = 'interrupted: application stopped while action was running'
-		WHERE status = 'running'`)
-	return wrap("recovering interrupted output commands", err)
+		SET status = 'failed', attempts = attempts + 1, last_error = ?
+		WHERE status = 'running'`, interruptedOutputCommandError); err != nil {
+		return wrap("recovering interrupted output commands", err)
+	}
+	return wrap("committing interrupted output command recovery", tx.Commit())
 }
diff --git a/internal/desktop/pipeline/pipelinedb/queries.sql.go b/internal/desktop/pipeline/pipelinedb/queries.sql.go
index b9bd757c..c2888152 100644
--- a/internal/desktop/pipeline/pipelinedb/queries.sql.go
+++ b/internal/desktop/pipeline/pipelinedb/queries.sql.go
@@ -236,6 +236,33 @@ func (q *Queries) EnqueueOutputCommand(ctx context.Context, arg EnqueueOutputCom
 	return err
 }
 
+const findRunningJobByCommandID = `-- name: FindRunningJobByCommandID :one
+SELECT id, created_at, updated_at, status, label, step, action_id, target, error, command_id FROM job
+WHERE command_id = ? AND status = 'running'
+ORDER BY id DESC
+LIMIT 1
+`
+
+// Restore a running job's identity after a worker or app restart so retries do
+// not create duplicate jobs and strand the original lifecycle as active.
+func (q *Queries) FindRunningJobByCommandID(ctx context.Context, commandID sql.NullInt64) (Job, error) {
+	row := q.db.QueryRowContext(ctx, findRunningJobByCommandID, commandID)
+	var i Job
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Status,
+		&i.Label,
+		&i.Step,
+		&i.ActionID,
+		&i.Target,
+		&i.Error,
+		&i.CommandID,
+	)
+	return i, err
+}
+
 const getConsumerOffset = `-- name: GetConsumerOffset :one
 SELECT consumer, "offset" FROM consumer_offset
 WHERE consumer = ?
@@ -288,6 +315,52 @@ func (q *Queries) GetSourceHeadPayload(ctx context.Context, arg GetSourceHeadPay
 	return payload, err
 }
 
+const insertJob = `-- name: InsertJob :one
+INSERT INTO job (created_at, updated_at, status, label, step, action_id, target, error, command_id)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+RETURNING id, created_at, updated_at, status, label, step, action_id, target, error, command_id
+`
+
+type InsertJobParams struct {
+	CreatedAt int64         `json:"created_at"`
+	UpdatedAt int64         `json:"updated_at"`
+	Status    string        `json:"status"`
+	Label     string        `json:"label"`
+	Step      string        `json:"step"`
+	ActionID  string        `json:"action_id"`
+	Target    string        `json:"target"`
+	Error     string        `json:"error"`
+	CommandID sql.NullInt64 `json:"command_id"`
+}
+
+func (q *Queries) InsertJob(ctx context.Context, arg InsertJobParams) (Job, error) {
+	row := q.db.QueryRowContext(ctx, insertJob,
+		arg.CreatedAt,
+		arg.UpdatedAt,
+		arg.Status,
+		arg.Label,
+		arg.Step,
+		arg.ActionID,
+		arg.Target,
+		arg.Error,
+		arg.CommandID,
+	)
+	var i Job
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Status,
+		&i.Label,
+		&i.Step,
+		&i.ActionID,
+		&i.Target,
+		&i.Error,
+		&i.CommandID,
+	)
+	return i, err
+}
+
 const insertNodeRun = `-- name: InsertNodeRun :exec
 INSERT INTO node_run (flow_id, node_id, ok, in_count, out_count, drop_count, err, ended_at, dur_ms)
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -320,6 +393,48 @@ func (q *Queries) InsertNodeRun(ctx context.Context, arg InsertNodeRunParams) er
 	return err
 }
 
+const listActiveJobs = `-- name: ListActiveJobs :many
+SELECT id, created_at, updated_at, status, label, step, action_id, target, error, command_id FROM job
+WHERE status IN ('queued', 'running') OR (status IN ('done', 'failed') AND updated_at >= ?)
+ORDER BY id DESC
+`
+
+// Non-terminal jobs plus terminal jobs updated within a recency window, newest
+// first. Drives the auto-hiding titlebar chip.
+func (q *Queries) ListActiveJobs(ctx context.Context, updatedAt int64) ([]Job, error) {
+	rows, err := q.db.QueryContext(ctx, listActiveJobs, updatedAt)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []Job{}
+	for rows.Next() {
+		var i Job
+		if err := rows.Scan(
+			&i.ID,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+			&i.Status,
+			&i.Label,
+			&i.Step,
+			&i.ActionID,
+			&i.Target,
+			&i.Error,
+			&i.CommandID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const listActivityEvents = `-- name: ListActivityEvents :many
 SELECT id, created_at, category, severity, title, body, source, metadata FROM activity_event
 WHERE id < ?
@@ -436,6 +551,50 @@ func (q *Queries) ListFeedItemsByFeed(ctx context.Context, feedID string) ([]Lis
 	return items, nil
 }
 
+const listJobs = `-- name: ListJobs :many
+SELECT id, created_at, updated_at, status, label, step, action_id, target, error, command_id FROM job WHERE id < ? ORDER BY id DESC LIMIT ?
+`
+
+type ListJobsParams struct {
+	ID    int64 `json:"id"`
+	Limit int64 `json:"limit"`
+}
+
+// Newest first, paged by a descending id cursor (same shape as ListActivityEvents).
+func (q *Queries) ListJobs(ctx context.Context, arg ListJobsParams) ([]Job, error) {
+	rows, err := q.db.QueryContext(ctx, listJobs, arg.ID, arg.Limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []Job{}
+	for rows.Next() {
+		var i Job
+		if err := rows.Scan(
+			&i.ID,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+			&i.Status,
+			&i.Label,
+			&i.Step,
+			&i.ActionID,
+			&i.Target,
+			&i.Error,
+			&i.CommandID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const listNodeRunsByFlow = `-- name: ListNodeRunsByFlow :many
 SELECT flow_id, node_id, ok, in_count, out_count, drop_count, err, ended_at, dur_ms FROM node_run
 WHERE flow_id = ?
@@ -668,6 +827,23 @@ func (q *Queries) PruneNodeRuns(ctx context.Context, offset int64) error {
 	return err
 }
 
+const pruneTerminalJobs = `-- name: PruneTerminalJobs :exec
+DELETE FROM job
+WHERE id IN (
+    SELECT id FROM job
+    WHERE status IN ('done', 'failed')
+    ORDER BY id DESC
+    LIMIT -1 OFFSET ?
+)
+`
+
+// Never remove active jobs: only terminal done/failed history is bounded
+// (mirrors PruneTerminalOutputCommands).
+func (q *Queries) PruneTerminalJobs(ctx context.Context, offset int64) error {
+	_, err := q.db.ExecContext(ctx, pruneTerminalJobs, offset)
+	return err
+}
+
 const pruneTerminalOutputCommands = `-- name: PruneTerminalOutputCommands :exec
 DELETE FROM output_command
 WHERE id IN (
@@ -748,6 +924,87 @@ func (q *Queries) RetryOutputCommand(ctx context.Context, arg RetryOutputCommand
 	return err
 }
 
+const setJobRunning = `-- name: SetJobRunning :one
+UPDATE job SET updated_at = ?, status = ?, step = ?, command_id = ?
+WHERE id = ?
+RETURNING id, created_at, updated_at, status, label, step, action_id, target, error, command_id
+`
+
+type SetJobRunningParams struct {
+	UpdatedAt int64         `json:"updated_at"`
+	Status    string        `json:"status"`
+	Step      string        `json:"step"`
+	CommandID sql.NullInt64 `json:"command_id"`
+	ID        int64         `json:"id"`
+}
+
+// Advance a job to running and link its output_command. This is the ONLY write
+// that sets command_id, so terminal transitions can never null it out.
+func (q *Queries) SetJobRunning(ctx context.Context, arg SetJobRunningParams) (Job, error) {
+	row := q.db.QueryRowContext(ctx, setJobRunning,
+		arg.UpdatedAt,
+		arg.Status,
+		arg.Step,
+		arg.CommandID,
+		arg.ID,
+	)
+	var i Job
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Status,
+		&i.Label,
+		&i.Step,
+		&i.ActionID,
+		&i.Target,
+		&i.Error,
+		&i.CommandID,
+	)
+	return i, err
+}
+
+const setJobStatus = `-- name: SetJobStatus :one
+UPDATE job SET updated_at = ?, status = ?, step = ?, error = ?
+WHERE id = ?
+RETURNING id, created_at, updated_at, status, label, step, action_id, target, error, command_id
+`
+
+type SetJobStatusParams struct {
+	UpdatedAt int64  `json:"updated_at"`
+	Status    string `json:"status"`
+	Step      string `json:"step"`
+	Error     string `json:"error"`
+	ID        int64  `json:"id"`
+}
+
+// Advance a job's status/step/error WITHOUT touching command_id (used by the
+// done/failed terminal transitions). Splitting this from SetJobRunning avoids a
+// read-modify-write and prevents clobbering the command link.
+func (q *Queries) SetJobStatus(ctx context.Context, arg SetJobStatusParams) (Job, error) {
+	row := q.db.QueryRowContext(ctx, setJobStatus,
+		arg.UpdatedAt,
+		arg.Status,
+		arg.Step,
+		arg.Error,
+		arg.ID,
+	)
+	var i Job
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.Status,
+		&i.Label,
+		&i.Step,
+		&i.ActionID,
+		&i.Target,
+		&i.Error,
+		&i.CommandID,
+	)
+	return i, err
+}
+
 const upsertFeedItem = `-- name: UpsertFeedItem :exec
 INSERT INTO feed_item (feed_id, item_id, payload, updated_at, unread, source_topic, snapshot_id)
 VALUES (?, ?, ?, ?, ?, ?, ?)
diff --git a/internal/desktop/pipeline/pipelinedb/queries/queries.sql b/internal/desktop/pipeline/pipelinedb/queries/queries.sql
index 23751d18..15018e64 100644
--- a/internal/desktop/pipeline/pipelinedb/queries/queries.sql
+++ b/internal/desktop/pipeline/pipelinedb/queries/queries.sql
@@ -194,3 +194,53 @@ WHERE id IN (
     ORDER BY id DESC
     LIMIT -1 OFFSET ?
 );
+
+-- name: InsertJob :one
+INSERT INTO job (created_at, updated_at, status, label, step, action_id, target, error, command_id)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+RETURNING *;
+
+-- name: SetJobRunning :one
+-- Advance a job to running and link its output_command. This is the ONLY write
+-- that sets command_id, so terminal transitions can never null it out.
+UPDATE job SET updated_at = ?, status = ?, step = ?, command_id = ?
+WHERE id = ?
+RETURNING *;
+
+-- name: SetJobStatus :one
+-- Advance a job's status/step/error WITHOUT touching command_id (used by the
+-- done/failed terminal transitions). Splitting this from SetJobRunning avoids a
+-- read-modify-write and prevents clobbering the command link.
+UPDATE job SET updated_at = ?, status = ?, step = ?, error = ?
+WHERE id = ?
+RETURNING *;
+
+-- name: FindRunningJobByCommandID :one
+-- Restore a running job's identity after a worker or app restart so retries do
+-- not create duplicate jobs and strand the original lifecycle as active.
+SELECT * FROM job
+WHERE command_id = ? AND status = 'running'
+ORDER BY id DESC
+LIMIT 1;
+
+-- name: ListJobs :many
+-- Newest first, paged by a descending id cursor (same shape as ListActivityEvents).
+SELECT * FROM job WHERE id < ? ORDER BY id DESC LIMIT ?;
+
+-- name: ListActiveJobs :many
+-- Non-terminal jobs plus terminal jobs updated within a recency window, newest
+-- first. Drives the auto-hiding titlebar chip.
+SELECT * FROM job
+WHERE status IN ('queued', 'running') OR (status IN ('done', 'failed') AND updated_at >= ?)
+ORDER BY id DESC;
+
+-- name: PruneTerminalJobs :exec
+-- Never remove active jobs: only terminal done/failed history is bounded
+-- (mirrors PruneTerminalOutputCommands).
+DELETE FROM job
+WHERE id IN (
+    SELECT id FROM job
+    WHERE status IN ('done', 'failed')
+    ORDER BY id DESC
+    LIMIT -1 OFFSET ?
+);
diff --git a/internal/desktop/pipeline/pipelinedb/retention.go b/internal/desktop/pipeline/pipelinedb/retention.go
index fdb24544..7c24cbe7 100644
--- a/internal/desktop/pipeline/pipelinedb/retention.go
+++ b/internal/desktop/pipeline/pipelinedb/retention.go
@@ -17,6 +17,9 @@ type RetentionPolicy struct {
 	// ActivityEventLimit is the total number of newest activity_event rows to
 	// retain for the Activity view's audit history.
 	ActivityEventLimit int64
+	// JobLimit is the number of newest done/failed job rows to retain.
+	// Non-terminal jobs are never pruned.
+	JobLimit int64
 }
 
 // DefaultRetentionPolicy keeps enough recent history for the desktop's debug
@@ -26,6 +29,7 @@ func DefaultRetentionPolicy() RetentionPolicy {
 		NodeRunLimit:               10_000,
 		TerminalOutputCommandLimit: 2_000,
 		ActivityEventLimit:         5_000,
+		JobLimit:                   2_000,
 	}
 }
 
@@ -43,9 +47,9 @@ type RetentionResult struct {
 // hold retention because re-enabling one intentionally starts from the then
 // current log rather than replaying data accumulated while it was disabled.
 //
-// Node runs and terminal output-command rows are bounded independently. The
-// latter intentionally excludes pending and running commands; losing either
-// could drop or duplicate a side effect.
+// Node runs, terminal output-command rows, activity events, and terminal jobs
+// are bounded independently. Command and job retention intentionally excludes
+// non-terminal rows; losing either could drop work or strand visible state.
 func (db *DB) Prune(ctx context.Context, enabledConsumers []string, policy RetentionPolicy) (RetentionResult, error) {
 	if policy.NodeRunLimit < 0 {
 		return RetentionResult{}, fmt.Errorf("node run retention limit must not be negative")
@@ -56,6 +60,9 @@ func (db *DB) Prune(ctx context.Context, enabledConsumers []string, policy Reten
 	if policy.ActivityEventLimit < 0 {
 		return RetentionResult{}, fmt.Errorf("activity event retention limit must not be negative")
 	}
+	if policy.JobLimit < 0 {
+		return RetentionResult{}, fmt.Errorf("job retention limit must not be negative")
+	}
 
 	enabled := uniqueConsumers(enabledConsumers)
 	result := RetentionResult{}
@@ -100,6 +107,9 @@ func (db *DB) Prune(ctx context.Context, enabledConsumers []string, policy Reten
 		if err := q.PruneActivityEvents(ctx, policy.ActivityEventLimit); err != nil {
 			return fmt.Errorf("pruning activity events: %w", err)
 		}
+		if err := q.PruneTerminalJobs(ctx, policy.JobLimit); err != nil {
+			return fmt.Errorf("pruning terminal jobs: %w", err)
+		}
 		return nil
 	})
 	if err != nil {
diff --git a/internal/desktop/pipeline/pipelinedb/retention_test.go b/internal/desktop/pipeline/pipelinedb/retention_test.go
index a406a0f0..f887d0ad 100644
--- a/internal/desktop/pipeline/pipelinedb/retention_test.go
+++ b/internal/desktop/pipeline/pipelinedb/retention_test.go
@@ -68,8 +68,16 @@ func TestPrune_BoundsOnlyTerminalHistory(t *testing.T) {
 		`, fmt.Sprintf("action-%d", i), fmt.Sprintf("key-%d", i), status, i)
 		require.NoError(t, err)
 	}
+	for i, status := range []string{"done", "failed", "done", "queued", "running"} {
+		_, err := database.InsertJob(ctx, JobRecord{
+			CreatedAt: int64(i), UpdatedAt: int64(i), Status: status, Label: fmt.Sprintf("job-%d", i),
+		})
+		require.NoError(t, err)
+	}
 
-	_, err := database.Prune(ctx, nil, RetentionPolicy{NodeRunLimit: 2, TerminalOutputCommandLimit: 2})
+	_, err := database.Prune(ctx, nil, RetentionPolicy{
+		NodeRunLimit: 2, TerminalOutputCommandLimit: 2, JobLimit: 2,
+	})
 	require.NoError(t, err)
 
 	var nodeRuns int
@@ -87,6 +95,19 @@ func TestPrune_BoundsOnlyTerminalHistory(t *testing.T) {
 	}
 	require.NoError(t, rows.Err())
 	assert.Equal(t, []string{"failed", "done", "pending", "running"}, statuses)
+
+	jobs, err := database.ListJobs(ctx, 0, 10)
+	require.NoError(t, err)
+	require.Len(t, jobs, 4)
+	assert.Equal(t, []string{"running", "queued", "done", "failed"}, []string{
+		jobs[0].Status, jobs[1].Status, jobs[2].Status, jobs[3].Status,
+	})
+}
+
+func TestPrune_RejectsNegativeJobLimit(t *testing.T) {
+	database := openTestDB(t)
+	_, err := database.Prune(context.Background(), nil, RetentionPolicy{JobLimit: -1})
+	require.EqualError(t, err, "job retention limit must not be negative")
 }
 
 func TestOpen_FreshDB_HasRetentionIndexes(t *testing.T) {
diff --git a/mise.toml b/mise.toml
index 0e9a489c..12b7cf64 100644
--- a/mise.toml
+++ b/mise.toml
@@ -19,9 +19,9 @@ HIVE_LOG_FILE = "./dev.log"
 
 [tasks."generate:enums"]
 description = "Generate enum methods using go-enum"
-sources = ["internal/core/action/type.go", "internal/core/hc/item.go", "internal/core/notify/store.go", "internal/core/todo/todo.go", "internal/sources/backend.go", "internal/desktop/activity/activity.go"]
-outputs = ["internal/core/action/type_enum.go", "internal/core/hc/item_enum.go", "internal/core/notify/store_enum.go", "internal/core/todo/todo_enum.go", "internal/sources/backend_enum.go", "internal/desktop/activity/activity_enum.go"]
-run = "go-enum --nocase --names --marshal -f internal/core/action/type.go -f internal/core/hc/item.go -f internal/core/notify/store.go -f internal/core/todo/todo.go -f internal/sources/backend.go -f internal/desktop/activity/activity.go"
+sources = ["internal/core/action/type.go", "internal/core/hc/item.go", "internal/core/notify/store.go", "internal/core/todo/todo.go", "internal/sources/backend.go", "internal/desktop/activity/activity.go", "internal/desktop/jobs/jobs.go"]
+outputs = ["internal/core/action/type_enum.go", "internal/core/hc/item_enum.go", "internal/core/notify/store_enum.go", "internal/core/todo/todo_enum.go", "internal/sources/backend_enum.go", "internal/desktop/activity/activity_enum.go", "internal/desktop/jobs/jobs_enum.go"]
+run = "go-enum --nocase --names --marshal -f internal/core/action/type.go -f internal/core/hc/item.go -f internal/core/notify/store.go -f internal/core/todo/todo.go -f internal/sources/backend.go -f internal/desktop/activity/activity.go -f internal/desktop/jobs/jobs.go"
 
 [tasks.generate]
 description = "Run all code generators"