From 853db94887650dfb13e6608c4bb966fdacb52c67 Mon Sep 17 00:00:00 2001
From: barlind <tobias@barlind.se>
Date: Sun, 31 May 2026 09:27:28 +0200
Subject: [PATCH] Implement

---
 CHANGELOG.md                                 |    1 +
 docs/capability-domains.md                   |   23 +-
 docs/capability-recipes.md                   |   65 +
 docs/capability-roadmap.md                   |   13 +-
 docs/capability-safety-matrix.md             |    3 +-
 plugins/capability_inspector/screen.js       |   56 +-
 specs/009-jobs/tasks.md                      |  144 +--
 static/capabilities.js                       |   18 +-
 static/capabilities/jobs.js                  | 1127 ++++++++++++++++++
 static/index.html                            |    1 +
 tests/js/capabilities_diagnostics.test.js    |   10 +-
 tests/js/capability_inspector_render.test.js |   38 +
 tests/js/jobs_compat.test.js                 |   58 +
 tests/js/jobs_diagnostics.test.js            |   73 ++
 tests/js/jobs_domain.test.js                 |   78 ++
 tests/js/jobs_scheduling.test.js             |   71 ++
 tests/js/jobs_test_harness.js                |  159 +++
 tests/test_plugin_runtime_idempotence.py     |    8 +-
 18 files changed, 1853 insertions(+), 93 deletions(-)
 create mode 100644 static/capabilities/jobs.js
 create mode 100644 tests/js/jobs_compat.test.js
 create mode 100644 tests/js/jobs_diagnostics.test.js
 create mode 100644 tests/js/jobs_domain.test.js
 create mode 100644 tests/js/jobs_scheduling.test.js
 create mode 100644 tests/js/jobs_test_harness.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d2eb62..f5d611d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -56,6 +56,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Audio-input control plane** — makes `audio-input` the redaction-safe source of truth for instrument input discovery and lifecycle. Core now exposes `list-sources`, `select-source`, `open-source`, and `close-source` through the capability runtime, persists selected logical sources, keeps inspect/list/select prompt-free, routes provider `source.open`/`source.close` operations with bounded outcomes, shares compatible open sessions across requesters, suppresses compatibility-backed duplicate sources when a native provider owns the same logical key, and expands audio-session diagnostics/Capability Inspector rendering for selected input, open sessions, bridge hits, storage status, and permission/device failures without exposing raw device labels or live audio handles.
 - **Audio-monitoring control plane** — makes `audio-monitoring` the shared live-monitoring coordinator. Core now exposes provider registration/list/selection, explicit user-action `start`, requester-counted `stop`, prompt-free `inspect`/`monitoring.status`, and `set-direct-monitor` through the capability runtime. Monitoring starts integrate with selected `audio-input` readiness, background requesters can only attach to active compatible sessions, active sessions survive song/playback stops without auto-resuming after reload, native providers suppress compatibility-backed legacy monitor paths, and diagnostics/Capability Inspector now show providers, sessions, requesters, direct-monitor state, bridge hits, and distinct safe outcomes (`provider-selection-required`, `user-action-required`, `incompatible`, `unavailable`, `stopped`, etc.) without exposing raw audio/device data.
 - **Playback control plane** — promotes `playback` to an active core capability domain for song transport, timing, loop, route, requester/observer, bridge, and diagnostics state. Core now exposes `inspect`, user-authorized `start`, `pause`, `resume`, `stop`, `seek`, `set-loop`, and `clear-loop` through the capability runtime while `static/app.js` keeps raw `<audio>`/JUCE handles private behind a redaction-safe adapter. Playback diagnostics use pseudonymous targets in exported bundles, local display labels only in the Capability Inspector, bounded recent outcomes/events, and bridge accounting for `window.playSong`, legacy `song:*` events, `window.slopsmith` transport helpers, loop helpers, and browser/native route handoff.
+- **Jobs control plane** — promotes `jobs` to an active privileged capability domain for long-running plugin work. Core now exposes provider registration, selected-provider persistence, approval-gated enqueue/retry, capacity-aware scheduling, prompt-free list/inspect, cancel/pause/resume/retry coordination, reload recovery for provider-declared references, compatibility bridge hits, and `slopsmith.jobs.diagnostics.v1` snapshots. Providers keep actual writes/downloads/subprocesses private; diagnostics redact paths, filenames, URLs, tokens, command lines, media/artifacts, recordings, live handles, and provider-private payloads.
 - **3D highway — Tone HUD, fret dividers, chord-diagram toggle, FPS counter.** The bundled `plugins/highway_3d` gains an amber **Tone-change HUD** (shows the active tone and the next scheduled tone change; position / size / visibility configurable in settings), a **fret-dividers** toggle (vertical dividers on the highway, on by default, via `h3dBgSetFretDividersVisible`), a **chord-diagram visibility** toggle (`h3dBgSetChordDiagramVisible`), and an **FPS counter** setting migrated to `BG_DEFAULTS.fpsVisible` (drops the legacy `h3d_showFps` localStorage key). Chord-diagram position is restricted to `tl`/`tr`; legacy `bl`/`br` values are coerced on load. Perf: accent-halo shell descriptors are pre-built per string in `initScene()` and the chord-verdict cache key is encoded as a number, eliminating per-frame allocations in the `drawNote()` and chord hot paths.
 - **Sloppak assembly preserves a short preview clip.** When a source chart carries a separate short browser-preview audio clip alongside the full song, the sloppak assembler now decodes it to `preview.ogg` at the sloppak root and records it under a new top-level `preview:` manifest key (POSIX relpath, same shape as `lyrics`/`cover`). A failed preview decode is logged at debug and skipped without aborting the overall build. Sources with no separate preview are unaffected. Older sloppak readers ignore the unknown `preview` key, so the change is purely additive (sloppak-spec.md §5.5 backward-compat). Documented in `docs/sloppak-spec.md` §2 alongside the other optional top-level keys. Enables [`slopsmith-plugin-song-preview`](https://github.com/got-feedback/feedback-plugin-song-preview) to render hover-to-listen previews for sloppaks without seeking into the full audio.
 - **Generic plugin asset route** — `GET /api/plugins/{plugin_id}/assets/{path}` serves arbitrary static files a plugin bundles under its own `assets/` directory (AudioWorklet modules, WASM, images, etc.), so plugins can self-host browser-fetchable assets without a CDN (Principle II). Containment is enforced by `lib/safepath.safe_join` against `<plugin>/assets/`, so `..` traversal, absolute paths, and NUL bytes cannot escape `assets/` to reach a plugin's Python modules. `.js` is served as `application/javascript`. First consumer: the stems plugin's pitch-preserving time-stretch worklet.
diff --git a/docs/capability-domains.md b/docs/capability-domains.md
index ec6cf08..20bddb7 100644
--- a/docs/capability-domains.md
+++ b/docs/capability-domains.md
@@ -153,6 +153,18 @@ The legacy chart-coupled surface — `highway.setNoteStateProvider(fn)`, the sin
 
 Diagnostics live under `slopsmith.note_detection_capability.v1` and contain provider ids/labels/kinds, binding summaries (requester, provider, redacted context, target size), availability, and the last bounded outcome (event, binding, provider, MIDI number, hit flag) — never raw audio buffers, sample data, device labels, or song identity.
 
+## Jobs Control Plane
+
+The jobs slice promotes `jobs` as a privileged core provider-coordinator implemented by [static/capabilities/jobs.js](../static/capabilities/jobs.js). It coordinates long-running plugin work such as conversion, import, cache-building, update, preview, and studio-style background tasks while providers keep the actual file writes, subprocesses, downloads, and private payloads inside their own code.
+
+The public command surface is `register-provider`, `unregister-provider`, `list-providers`, `enqueue`, `list`, `inspect`, `cancel`, `pause`, `resume`, `retry`, and `record-bridge-hit`. Provider operations are `job.enqueue`, `job.status`, `job.cancel`, `job.pause`, `job.resume`, `job.retry`, and `job.recover`. `list` and `inspect` are prompt-free and side-effect-free: they never trigger provider work, writes, downloads, subprocesses, or external calls. Fresh privileged `enqueue` and `retry` requests require an explicit `authorization: "user-action"` or a matching approved-continuation scope before provider callbacks run.
+
+Jobs are scheduled by provider capacity and priority (`user-approved-interactive` before `background-maintenance`). State transitions are explicit (`queued`, `running`, `paused`, `cancellation-requested`, terminal cancelled/completed/failed/provider-unavailable/orphaned), and outcomes use the shared canonical vocabulary: `handled`, `queued`, `denied`, `user-action-required`, `unavailable`, `no-owner`, `no-handler`, `no-target`, `unsupported-command`, `unsupported-operation`, `incompatible`, `incompatible-version`, `provider-selection-required`, `validation-failed`, `stale`, `cancelled`, `completed`, `failed`, `timeout`, and `retry-started`.
+
+Diagnostics live under `slopsmith.jobs.diagnostics.v1`. Snapshots include provider summaries, selected/default providers, active/queued/paused/recent-terminal jobs, bounded per-job history, recent outcomes, bridge hits, limits, and notes. Browser persistence is limited to selected provider choices and provider-declared recoverable job references; it does not store raw payloads, non-recoverable active job state, file paths, command lines, URLs, tokens, media buffers, recordings, live handles, or provider-private data. On reload, only provider-declared recoverable jobs are restored; the rest become orphaned or provider-unavailable with a safe reason.
+
+Compatibility bridge hits such as `jobs.legacy-plugin-queue`, `jobs.legacy-status-screen`, `jobs.legacy-backend-route`, `jobs.legacy-progress-poll`, and `jobs.legacy-update-flow` are diagnostics-only attribution. They never grant approval or execute queued work by themselves.
+
 ## Capability Roles
 
 Use capability declarations for provider/requester/observer relationships:
@@ -180,7 +192,9 @@ Core domains include review metadata in diagnostics:
 - `active`: wired to current Slopsmith behavior and expected to work as an integration point.
 - `diagnostic`: support/inspection-only runtime surfaces.
 
-PR1 includes only the delivered domains listed in [capability-roadmap.md](capability-roadmap.md): `pipeline`, `diagnostics`, and `library`. The follow-up audio graph/session slice promotes `audio-mix`, `audio-input`, `audio-monitoring`, and a coordinated `stems` surface. The playback slice promotes `playback` as an active transport control plane. The audio-effects slice promotes provider-selected effect-chain planning while leaving physical processor loading to compatible executors such as trusted Desktop native audio or a browser/WASM executor. The visualization slice promotes `visualization` as the highway renderer provider-coordinator, and the note-detection slice (spec 009) promotes `note-detection` as the detection-binding control plane. Backend routes, app UI, settings, and other hardware-facing domains remain documented in the roadmap and safety matrix until their own host workflow/provider slice exists.
+PR1 includes only the delivered domains listed in [capability-roadmap.md](capability-roadmap.md): `pipeline`, `diagnostics`, and `library`. The follow-up audio graph/session slice promotes `audio-mix`, `audio-input`, `audio-monitoring`, and a coordinated `stems` surface. The playback slice promotes `playback` as an active transport control plane. The audio-effects slice promotes provider-selected effect-chain planning while leaving physical processor loading to compatible executors such as trusted Desktop native audio or a browser/WASM executor. The visualization slice promotes `visualization` as the highway renderer provider-coordinator, the note-detection slice (spec 009) promotes `note-detection` as the detection-binding control plane, and the jobs slice promotes `jobs` as a privileged provider-coordinator for long-running work. Backend routes, app UI, settings, and other hardware-facing domains remain documented in the roadmap and safety matrix until their own host workflow/provider slice exists.
+
+PR1 includes only the delivered domains listed in [capability-roadmap.md](capability-roadmap.md): `pipeline`, `diagnostics`, and `library`. The follow-up audio graph/session slice promotes `audio-mix`, `audio-input`, `audio-monitoring`, and a coordinated `stems` surface. The playback slice promotes `playback` as an active transport control plane. The audio-effects slice promotes provider-selected effect-chain planning while leaving physical processor loading to compatible executors such as trusted Desktop native audio or a browser/WASM executor. The jobs slice promotes `jobs` as a privileged provider-coordinator for long-running work. Backend routes, app UI, settings, visualization, note-detection, and other hardware-facing domains remain documented in the roadmap and safety matrix until their own host workflow/provider slice exists.
 
 Capability metadata is versioned by the `capability-pipelines.v1` standard. Invalid roles, commands, operations, requests, observes, emits, events, owner kinds, compatibility modes, ownership policies, safety classes, or version fields are excluded from the capability graph and surfaced through `capability_validation_warnings`; legacy plugin fields continue to load through their existing app paths. Plugins that declare a future `capability-pipelines` version are reported through `capability_unsupported_versions` and their runtime handlers are marked incompatible.
 
@@ -228,11 +242,13 @@ The compatibility ownership vocabulary remains:
 - `privileged`: command execution needs an explicit enforcement plan before shipping.
 - `diagnostic-only`: read-only support and inspector surfaces.
 
-Dispatch results use explicit outcomes: `handled`, `transformed`, `denied`, `failed`, `degraded`, `short-circuited`, `overridden`, `no-owner`, `no-handler`, `no-target`, `unsupported-command`, `incompatible`, `incompatible-version`, `unavailable`, `provider-selection-required`, `user-action-required`, `stale`, `cancelled`, and `stopped`. No-owner, no-handler, no-target, unsupported-command, incompatible, incompatible-version, provider-selection-required, user-action-required, stale, and cancelled decisions are recorded in diagnostics so support bundles explain why nothing happened.
+Dispatch results use explicit outcomes: `handled`, `transformed`, `denied`, `failed`, `degraded`, `short-circuited`, `overridden`, `no-owner`, `no-handler`, `no-target`, `unsupported-command`, `unsupported-operation`, `incompatible`, `incompatible-version`, `unavailable`, `provider-selection-required`, `user-action-required`, `stale`, `queued`, `validation-failed`, `cancelled`, `completed`, `timeout`, `retry-started`, and `stopped`. No-owner, no-handler, no-target, unsupported-command, unsupported-operation, incompatible, incompatible-version, provider-selection-required, user-action-required, stale, queued, validation-failed, cancelled, completed, timeout, and retry-started decisions are recorded in diagnostics so support bundles explain what happened.
 
 ## Deferred Core Adapters
 
-UI placement and settings contributions are real Slopsmith surfaces, but they are not PR1 capability contracts (visualization is active as of the cap:6 slice; note-detection as of the spec-009 slice). Audio mixer/session domains are active as of the audio graph/session slice, playback is active as of the playback control-plane slice, and audio-effects is active as a provider/route/chain-plan coordinator; plugins should keep using current documented APIs for remaining areas until the corresponding domain PR ships the host workflow, command/event contract, compatibility shims, diagnostics fields, and tests.
+UI placement and settings contributions are real Slopsmith surfaces, but they are not PR1 capability contracts (visualization is active as of the cap:6 slice, note-detection as of the spec-009 slice, and jobs as of the jobs control-plane slice). Audio mixer/session domains are active as of the audio graph/session slice, playback is active as of the playback control-plane slice, and audio-effects is active as a provider/route/chain-plan coordinator; plugins should keep using current documented APIs for remaining areas until the corresponding domain PR ships the host workflow, command/event contract, compatibility shims, diagnostics fields, and tests.
+
+UI placement, settings contributions, visualization, and note-detection are real Slopsmith surfaces, but they are not PR1 capability contracts. Audio mixer/session domains are active as of the audio graph/session slice, playback is active as of the playback control-plane slice, audio-effects is active as a provider/route/chain-plan coordinator, and jobs are active as of the jobs control-plane slice; plugins should keep using current documented APIs for remaining areas until the corresponding domain PR ships the host workflow, command/event contract, compatibility shims, diagnostics fields, and tests.
 
 The library provider workflow is the PR1 core adapter and is implemented natively as the `library` capability module. Provider refresh, selection, and sync run through `library` owner commands; backend provider registration remains the way providers enter the library registry, and the browser module turns that registry into provider participants. The app event bus continues to dispatch local `window.slopsmith` events for legacy listeners; playback now mirrors song transport, route, seek, and loop lifecycle into `playback`, and visualization attributes renderer selection/failure, while navigation, note, and route-only surfaces remain outside capability domains until their own slices land.
 
@@ -283,6 +299,7 @@ From the `slopsmith/` directory:
 ```bash
 node --check static/app.js
 node --check static/capabilities.js
+node --check static/capabilities/jobs.js
 node --check static/diagnostics.js
 node --check plugins/capability_inspector/screen.js
 node --test tests/js/*.test.js
diff --git a/docs/capability-recipes.md b/docs/capability-recipes.md
index 68903f2..8371de9 100644
--- a/docs/capability-recipes.md
+++ b/docs/capability-recipes.md
@@ -122,6 +122,71 @@ A route-only wrapper that uses the library capability without registering a brow
 }
 ```
 
+## Jobs Provider And Requester
+
+Plugins that run long-lived work should register as `jobs` providers and keep actual work private. The jobs host only stores safe summaries, provider ids, selected-provider choices, progress, terminal outcomes, and provider-declared recovery references.
+
+```json
+{
+  "id": "sloppak_converter",
+  "name": "Sloppak Converter",
+  "standards": ["capability-pipelines.v1", "plugin-runtime-idempotent.v1"],
+  "capabilities": {
+    "jobs": {
+      "roles": ["provider", "observer"],
+      "operations": ["job.enqueue", "job.status", "job.cancel", "job.retry", "job.recover"],
+      "events": ["queued", "started", "progress", "completed", "failed", "cancelled"],
+      "mode": "active",
+      "compatibility": "shim-allowed",
+      "ownership": "multi-provider",
+      "safety": "privileged",
+      "version": 1
+    }
+  }
+}
+```
+
+Runtime registration supplies the redaction-safe provider summary and operation callbacks:
+
+```js
+window.slopsmith.jobs.registerProvider({
+  providerId: 'sloppak_converter.jobs',
+  pluginId: 'sloppak_converter',
+  label: 'Sloppak Converter',
+  jobTypes: ['psarc-to-sloppak'],
+  actions: ['enqueue', 'inspect', 'cancel', 'retry', 'recover'],
+  capacity: { maxRunning: 1, maxQueued: 20 },
+  recoverySupport: { queued: true, running: false, paused: false },
+  operationHandlers: {
+    'job.enqueue': ({ job }) => startConversion(job),
+    'job.cancel': ({ job }) => cancelConversion(job.jobId),
+    'job.retry': ({ job }) => startConversion(job),
+  },
+});
+```
+
+Requesters enqueue privileged work only from a user action or matching approved continuation. Use safe labels and fingerprints rather than paths, filenames, URLs, command lines, or raw payloads.
+
+```js
+const result = await window.slopsmith.capabilities.dispatch({
+  capability: 'jobs',
+  command: 'enqueue',
+  source: 'sloppak_converter',
+  args: {
+    jobType: 'psarc-to-sloppak',
+    requester: 'sloppak_converter',
+    authorization: 'user-action',
+    target: { targetRef: 'song-target-abc123' },
+    inputs: { safeFingerprint: 'input-fingerprint-abc123' },
+    safeLabel: 'Convert selected song',
+  },
+});
+
+if (result.outcome === 'user-action-required') {
+  // Show an explicit button; do not start provider work in the background.
+}
+```
+
 ## Audio Mix Fader Provider
 
 Existing plugins can keep using `window.slopsmith.audio.registerFader(spec)` while migrating. The compatibility bridge records the fader as an `audio-mix` participant. New bundled code should prefer a native participant declaration plus the audio-session helper once available in its integration point.
diff --git a/docs/capability-roadmap.md b/docs/capability-roadmap.md
index 46699dc..e42f257 100644
--- a/docs/capability-roadmap.md
+++ b/docs/capability-roadmap.md
@@ -60,6 +60,14 @@ The progression slice (spec 010) promotes `progression` as an active exclusive-o
 
 Deferred follow-up slices: a `contributor` role so plugins ship their own challenge/quest content (drums challenges from a drums-scoring plugin, quest-pool entries from minigame plugins), and drums scoring wiring so `song_completed {instrument: "drums"}` goals become satisfiable.
 
+## Jobs Control Plane Slice
+
+The jobs slice promotes `jobs` from a deferred domain to an active privileged provider-coordinator. It owns provider registration, selected-provider persistence, capacity-aware scheduling, explicit user-approved enqueue/retry gates, prompt-free list/inspect, cancellation/pause/resume/retry coordination, reload recovery for provider-declared recoverable references, compatibility bridge hit accounting, and redaction-safe diagnostics under `slopsmith.jobs.diagnostics.v1`.
+
+Providers keep actual privileged work private. Core stores only safe job summaries, provider metadata, selected/default provider choices, bounded lifecycle history, terminal outcomes, and recovery references. It does not persist raw payloads, active non-recoverable work, DB schemas, paths, filenames, URLs, tokens, command lines, media/artifacts, recordings, live handles, or provider-private values.
+
+Jobs bridge removal gates are: bundled and first-party long-running workflows use native `jobs` provider registration/dispatch; normal conversion/import/update/cache smoke runs show no unexpected legacy bridge hits; diagnostics distinguish queued, denied, user-action-required, provider-selection-required, stale, cancelled, completed, failed, timeout, retry-started, orphaned, and provider-unavailable cases; repeated plugin hydration does not duplicate providers or jobs; and reload recovery restores only provider-declared safe references.
+
 ## Recommended Next Slices
 
 The plugin inventory suggests this migration order after the audio graph/session and playback slices:
@@ -69,6 +77,10 @@ The plugin inventory suggests this migration order after the audio graph/session
 3. UI contribution host: migrate navigation, plugin screens, player controls, player panels, overlays, shortcuts, and guided tours under placement/lifecycle policy.
 4. Backend and privileged capability cleanup: migrate routes, plugin lifecycle, media import/export, recording, external services, and subprocess-backed workflows with explicit user confirmation and diagnostics redaction.
 
+1. `note-detection`: formalize note-state providers, calibration diagnostics, audio-input coupling, and hit/miss event flow. Requesters should use `audio-input` for source selection/opening rather than owning device prompts directly.
+2. UI contribution host: migrate navigation, plugin screens, player controls, player panels, overlays, shortcuts, and guided tours under placement/lifecycle policy.
+3. Backend and privileged capability cleanup: migrate routes, plugin lifecycle, media import/export, recording, external services, and subprocess-backed workflows with explicit user confirmation and diagnostics redaction.
+
 ## UI/UX Migration Path
 
 This is the recommended order for UI/UX capability work only. It excludes audio semantics, backend route execution, media jobs, and plugin install/update behavior except where those systems need a visible contribution point.
@@ -107,7 +119,6 @@ These domains are planned but should stay out of the runtime graph until a host
 | `ui.player-panels` | exclusive-owner | safe | Player panel contributions, mount/unmount, visibility, ordering. | A panel host with layout and focus rules. |
 | `ui.player-overlays` | exclusive-owner | safe | Overlay contributions layered over player or highway surfaces. | Overlay placement and z-order rules that coexist with legacy overlays. |
 | `plugins` | exclusive-owner | privileged | Plugin enable/disable/install/update workflows. | Visible user confirmation, rollback, and disabled-handler enforcement. |
-| `jobs` | multi-provider | privileged | Long-running jobs, cancellation, status, failures. | Scheduling limits, cancellation semantics, and user-visible failures. |
 | `midi-control` | multi-provider | sensitive | MIDI device providers and control mappings. | Device consent and redacted diagnostics. |
 | `audio-input` | multi-provider | sensitive | Audio input device providers, source selection, open/close lifecycle, shared sessions, and redacted failure diagnostics. | Promoted by the audio graph/session slice and implemented by the audio-input control-plane slice. |
 | `tempo-clock` | multi-provider | safe | Tempo/clock provider registration and consumers. | A concrete tempo source and consumer workflow. |
diff --git a/docs/capability-safety-matrix.md b/docs/capability-safety-matrix.md
index 274457a..40e7fd7 100644
--- a/docs/capability-safety-matrix.md
+++ b/docs/capability-safety-matrix.md
@@ -15,6 +15,8 @@ Core domains also have a review scope. **Active contract** domains are wired to
 | stems | coordinator plus plugin provider | safe | inspect, mute, restore | stem.get-state, stem.apply-automation, stem.restore-automation | Core coordinates claims/overrides; the active Stems provider owns actual stem state/playback. |
 | playback | exclusive-owner | safe | inspect, start, pause, resume, stop, seek, set-loop, clear-loop, register-requester, register-observer | none | Core owns the transport control plane while `app.js` keeps raw media handles private. Fresh audible starts require explicit user action. Diagnostics expose pseudonymous targets, sanitized route/timing/loop state, requester/observer summaries, bridge hits, bounded recent outcomes, and no audio elements, native handles, decoded buffers, samples, waveforms, or recordings. |
 | progression | exclusive-owner | safe | inspect, record-event, list-shop, buy-item, equip-item | none | Core owns mastery rank, the challenge/quest engine, the Decibels wallet, and the cosmetics shop (spec 010). `record-event` accepts whitelisted types only (`minigame_run`); `song_completed` is server-derived in `/api/stats` and denied here. `buy-item`/`equip-item` require explicit user action. Decibels are play-earned only — no real-money path exists or may be added. Diagnostics (`slopsmith.progression.diag.v1`) carry content warnings, rank/level/quest counts, and wallet totals; no song filenames or display names. |
+
+| jobs | provider-coordinator | privileged | register-provider, unregister-provider, list-providers, enqueue, list, inspect, cancel, pause, resume, retry, record-bridge-hit | job.enqueue, job.status, job.cancel, job.pause, job.resume, job.retry, job.recover | Core coordinates provider selection, capacity scheduling, lifecycle state, recovery references, bridge hits, and diagnostics. Fresh privileged enqueue/retry requires explicit user approval or a matching approved-continuation scope. List/inspect are prompt-free and side-effect-free. Diagnostics redact paths, filenames, URLs, tokens, command lines, media/artifacts, recordings, handles, and provider-private payloads. |
 | audio-effects | provider-coordinator | sensitive | inspect, list-providers, register-provider, unregister-provider, select-chain, resolve-plan, inspect-route, bypass, restore, fallback, activate-segment, set-stage-bypass, set-stage-parameter, record-bridge-hit | chain.resolve, chain.inspect, segment.activate, stage.set-bypass, stage.set-parameter, route.bypass, route.restore | Core owns provider selection, route state, chain-plan schema validation, fallback accounting, and diagnostics. Providers propose opaque NAM/IR/VST/utility chain plans; trusted desktop/native code validates and loads processors. Chain selection and route bypass/restore require explicit user action or restored selection. Diagnostics omit raw paths, filenames, URLs, model/IR names, native preset JSON, VST state blobs, handles, callbacks, DOM nodes, audio buffers, samples, and waveforms. |
 
 | visualization | provider-coordinator | safe | inspect, list-providers, select-renderer, clear-renderer | renderer.create, renderer.destroy | Highway renderer provider registry, picker-delegated selection, auto-match attribution, and failure fallback. `renderer.create` maps to the legacy `window.slopsmithViz_*` factory `init(canvas, ctx)` call; `renderer.destroy` maps to the factory `destroy()` teardown. Legacy `type: "visualization"` manifests and `window.slopsmithViz_*` globals are accounted compatibility shims. Diagnostics carry provider ids/labels, selection source, last auto-match outcome, and last failure — no song filenames, titles, or arrangement names. |
@@ -37,7 +39,6 @@ These domains are expected future capability contracts, not current runtime grap
 | ui.player-panels | exclusive-owner | safe | register-contribution, mount, unmount, set-visible, reorder-by-policy, inspect | Needs a first-party panel host and layout policy. |
 | ui.player-overlays | exclusive-owner | safe | register-contribution, mount, unmount, set-visible, reorder-by-policy, inspect | Needs overlay placement rules that coexist with legacy highway overlays. |
 | plugins | exclusive-owner | privileged | enable, disable, install-missing, update, inspect | Needs explicit user confirmation for writes/install/update. |
-| jobs | multi-provider | privileged | register, inspect, cancel | Needs scheduling limits, cancellation semantics, and user-visible failures. |
 | midi-control | multi-provider | sensitive | register, inspect | Needs device consent and redacted diagnostics. |
 | tempo-clock | multi-provider | safe | register, inspect | Needs a concrete provider and consumer workflow. |
 
diff --git a/plugins/capability_inspector/screen.js b/plugins/capability_inspector/screen.js
index c8f0250..184edf4 100644
--- a/plugins/capability_inspector/screen.js
+++ b/plugins/capability_inspector/screen.js
@@ -11,7 +11,6 @@
         'ui.player-panels',
         'ui.player-overlays',
         'plugins',
-        'jobs',
         'midi-control',
         'tempo-clock',
     ]);
@@ -19,8 +18,8 @@
         Object.freeze({
             id: 'app-library',
             label: 'Application and Library',
-            summary: 'Navigation, plugin screens, settings, library sources, and tunings.',
-            domains: Object.freeze(['ui.navigation', 'ui.plugin-screens', 'settings', 'library', 'tuning']),
+            summary: 'Navigation, plugin screens, settings, library/tuning sources, and long-running jobs.',
+            domains: Object.freeze(['ui.navigation', 'ui.plugin-screens', 'settings', 'library', 'tuning', 'jobs']),
         }),
         Object.freeze({
             id: 'player-audio',
@@ -1474,6 +1473,54 @@
         catch (_) { return null; }
     }
 
+    function jobsSnapshot() {
+        const api = window.slopsmith && window.slopsmith.jobs;
+        if (!api || typeof api.snapshot !== 'function') return null;
+        try { return api.snapshot({ exportMode: 'local-inspector' }); }
+        catch (_) { return null; }
+    }
+
+    function jobsSupportPanel(jobsData) {
+        if (!jobsData || !jobsData.jobs) return '';
+        const providers = Array.isArray(jobsData.providers) ? jobsData.providers : [];
+        const selectedProviders = Array.isArray(jobsData.selectedProviders) ? jobsData.selectedProviders : [];
+        const active = Array.isArray(jobsData.jobs.active) ? jobsData.jobs.active : [];
+        const queued = Array.isArray(jobsData.jobs.queued) ? jobsData.jobs.queued : [];
+        const paused = Array.isArray(jobsData.jobs.paused) ? jobsData.jobs.paused : [];
+        const recentTerminal = Array.isArray(jobsData.jobs.recentTerminal) ? jobsData.jobs.recentTerminal : [];
+        const outcomes = Array.isArray(jobsData.outcomes) ? jobsData.outcomes.slice(-6) : [];
+        const bridgeHits = Array.isArray(jobsData.bridgeHits) ? jobsData.bridgeHits : [];
+        const unavailableProviders = providers.filter(provider => provider.availability && provider.availability !== 'available').length;
+        const terminalFailures = recentTerminal.filter(job => job && job.terminalOutcome && ['failed', 'timeout', 'provider-unavailable'].includes(job.terminalOutcome.status)).length;
+        return `<section class="mb-4 rounded-lg border border-gray-800 bg-dark-900/40 p-4" data-jobs-support>
+            <div class="flex flex-wrap items-center justify-between gap-3">
+                <div>
+                    <h3 class="text-sm font-semibold text-white">Jobs</h3>
+                    <p class="mt-1 text-xs text-gray-500">Provider selection, active work, scheduling, terminal outcomes, and bridge hits from the jobs host.</p>
+                </div>
+                <div class="flex flex-wrap gap-2">
+                    ${pill(`${providers.length} provider${providers.length === 1 ? '' : 's'}`, providers.length ? 'info' : 'muted')}
+                    ${pill(`${active.length} active`, active.length ? 'used' : 'muted')}
+                    ${pill(`${queued.length} queued`, queued.length ? 'warning' : 'muted')}
+                    ${pill(`${paused.length} paused`, paused.length ? 'warning' : 'muted')}
+                    ${pill(`${recentTerminal.length} recent terminal`, recentTerminal.length ? (terminalFailures ? 'conflict' : 'clean') : 'muted')}
+                    ${pill(`${bridgeHits.length} bridge hit${bridgeHits.length === 1 ? '' : 's'}`, bridgeHits.length ? 'used' : 'muted')}
+                    ${pill(`${unavailableProviders} unavailable provider${unavailableProviders === 1 ? '' : 's'}`, unavailableProviders ? 'warning' : 'muted')}
+                </div>
+            </div>
+            <div class="mt-3 grid gap-2 text-xs text-gray-400 md:grid-cols-2">
+                <div data-jobs-providers>Providers: ${providers.map(provider => `${text(provider.label || provider.providerId)}:${text(provider.availability || 'unknown')}:${text((provider.jobTypes || []).join('+') || 'none')}`).join(', ') || 'none'}</div>
+                <div data-jobs-selected>Selected: ${selectedProviders.map(selection => `${text(selection.jobType)}:${text(selection.providerId)}:${text(selection.source || 'stored')}`).join(', ') || 'none'}</div>
+                <div data-jobs-active>Active: ${active.map(job => `${text(job.safeLabel || job.jobId)}:${text(job.providerId)}:${text(job.progress && job.progress.percent != null ? `${job.progress.percent}%` : job.progress && job.progress.step || job.state)}`).join(', ') || 'none'}</div>
+                <div data-jobs-queued>Queued: ${queued.map(job => `${text(job.safeLabel || job.jobId)}:${text(job.providerId)}:${text(job.priority || 'normal')}`).join(', ') || 'none'}</div>
+                <div data-jobs-paused>Paused: ${paused.map(job => `${text(job.safeLabel || job.jobId)}:${text(job.providerId)}`).join(', ') || 'none'}</div>
+                <div data-jobs-terminal>Terminal: ${recentTerminal.map(job => `${text(job.safeLabel || job.jobId)}:${text(job.terminalOutcome && job.terminalOutcome.status || job.state)}${job.terminalOutcome && job.terminalOutcome.category ? `:${text(job.terminalOutcome.category)}` : ''}`).join(', ') || 'none'}</div>
+                <div data-jobs-bridges>Bridges: ${bridgeHits.map(hit => `${text(hit.bridgeId || hit.legacySurface)}:${text(hit.operation || 'unknown')}${hit.diagnosticsOnly ? ':diagnostics-only' : ''}`).join(', ') || 'none'}</div>
+                <div data-jobs-outcomes>Outcomes: ${outcomes.map(outcome => `${text(outcome.operation)}:${text(outcome.status || outcome.outcome)}`).join(', ') || 'none'}</div>
+            </div>
+        </section>`;
+    }
+
     function playbackSupportPanel(playbackData) {
         if (!playbackData || !playbackData.state) return '';
         const state = playbackData.state || {};
@@ -1642,9 +1689,10 @@
         const compatibilityShims = Array.isArray(data.compatibilityShims) ? data.compatibilityShims : [];
         if (summary) summary.innerHTML = summaryDashboard(data, pipelines, compatibilityShims);
         destroyActiveGraphs();
+        const jobsPanel = jobsSupportPanel(jobsSnapshot());
         const playbackPanel = playbackSupportPanel(playbackSnapshot());
         const audioPanel = audioDomainSupportPanel(audioSessionSnapshot());
-        content.innerHTML = playbackPanel + audioPanel + (selected
+        content.innerHTML = jobsPanel + playbackPanel + audioPanel + (selected
             ? visible.map(pipeline => domainGraphView(pipeline, shimsByCapability.get(pipeline.name) || [], expectedShimsByCapability.get(pipeline.name) || [])).join('')
             : groupedPipelines(visible).map(entry => pipelineGroupSection(entry, shimsByCapability, expectedShimsByCapability, { defaultExpanded: false })).join(''))
             || '<div class="text-gray-500 text-sm">No capability domains registered.</div>';
diff --git a/specs/009-jobs/tasks.md b/specs/009-jobs/tasks.md
index a2b8e0a..dc20d88 100644
--- a/specs/009-jobs/tasks.md
+++ b/specs/009-jobs/tasks.md
@@ -17,11 +17,11 @@
 
 **Purpose**: Create the jobs capability host entry points and test harness scaffolding used by all stories.
 
-- [ ] T001 Create jobs capability host shell with IIFE, event-bus access, diagnostics contribution placeholder, and public namespace in static/capabilities/jobs.js
-- [ ] T002 Load the jobs capability host after the capability runtime in static/index.html
-- [ ] T003 [P] Create jobs Node VM test harness with helpers for loading capabilities, dispatching jobs commands, capturing events, and reading diagnostics in tests/js/jobs_test_harness.js
-- [ ] T004 [P] Add jobs test file placeholders importing the harness in tests/js/jobs_domain.test.js, tests/js/jobs_scheduling.test.js, tests/js/jobs_diagnostics.test.js, and tests/js/jobs_compat.test.js
-- [ ] T005 [P] Add jobs inspector render fixture placeholders in tests/js/capability_inspector_render.test.js
+- [X] T001 Create jobs capability host shell with IIFE, event-bus access, diagnostics contribution placeholder, and public namespace in static/capabilities/jobs.js
+- [X] T002 Load the jobs capability host after the capability runtime in static/index.html
+- [X] T003 [P] Create jobs Node VM test harness with helpers for loading capabilities, dispatching jobs commands, capturing events, and reading diagnostics in tests/js/jobs_test_harness.js
+- [X] T004 [P] Add jobs test file placeholders importing the harness in tests/js/jobs_domain.test.js, tests/js/jobs_scheduling.test.js, tests/js/jobs_diagnostics.test.js, and tests/js/jobs_compat.test.js
+- [X] T005 [P] Add jobs inspector render fixture placeholders in tests/js/capability_inspector_render.test.js
 
 ---
 
@@ -31,15 +31,15 @@
 
 **CRITICAL**: No user story work can begin until this phase is complete.
 
-- [ ] T006 Promote `jobs` from reserved future domain to active privileged provider-coordinator review metadata in static/capabilities.js
-- [ ] T007 Add or verify the canonical jobs outcome inventory from FR-005 in capability outcome normalization in static/capabilities.js
-- [ ] T008 Implement constants for job states, outcomes, actions, priorities, limits, bridge ids, and diagnostics schema in static/capabilities/jobs.js
-- [ ] T009 Implement redaction and safe-value helpers for labels, reasons, target refs, logs, command-like text, URLs, local paths, and provider payloads in static/capabilities/jobs.js
-- [ ] T010 Implement provider, selected-provider, job, attempt, progress, outcome, history, and bridge in-memory stores with resettable test hooks in static/capabilities/jobs.js
-- [ ] T011 Implement diagnostics snapshot builder with active/queued/paused/recent terminal grouping and 64 KB budget trimming in static/capabilities/jobs.js
-- [ ] T012 Implement jobs capability owner registration with command/event declarations and diagnostics contribution in static/capabilities/jobs.js
-- [ ] T013 Add foundational harness assertions for active jobs owner registration, diagnostics schema, reset hooks, and no raw-provider-payload exposure in tests/js/jobs_domain.test.js
-- [ ] T014 [P] Add static idempotence expectations for active jobs domain and new outcomes in tests/test_plugin_runtime_idempotence.py
+- [X] T006 Promote `jobs` from reserved future domain to active privileged provider-coordinator review metadata in static/capabilities.js
+- [X] T007 Add or verify the canonical jobs outcome inventory from FR-005 in capability outcome normalization in static/capabilities.js
+- [X] T008 Implement constants for job states, outcomes, actions, priorities, limits, bridge ids, and diagnostics schema in static/capabilities/jobs.js
+- [X] T009 Implement redaction and safe-value helpers for labels, reasons, target refs, logs, command-like text, URLs, local paths, and provider payloads in static/capabilities/jobs.js
+- [X] T010 Implement provider, selected-provider, job, attempt, progress, outcome, history, and bridge in-memory stores with resettable test hooks in static/capabilities/jobs.js
+- [X] T011 Implement diagnostics snapshot builder with active/queued/paused/recent terminal grouping and 64 KB budget trimming in static/capabilities/jobs.js
+- [X] T012 Implement jobs capability owner registration with command/event declarations and diagnostics contribution in static/capabilities/jobs.js
+- [X] T013 Add foundational harness assertions for active jobs owner registration, diagnostics schema, reset hooks, and no raw-provider-payload exposure in tests/js/jobs_domain.test.js
+- [X] T014 [P] Add static idempotence expectations for active jobs domain and new outcomes in tests/test_plugin_runtime_idempotence.py
 
 **Checkpoint**: Jobs domain loads, registers as active privileged provider-coordinator, and can produce an empty redaction-safe diagnostics snapshot.
 
@@ -53,21 +53,21 @@
 
 ### Tests for User Story 1
 
-- [ ] T015 [US1] Add provider registration, re-registration idempotence, unavailable/degraded provider, and incompatible provider tests in tests/js/jobs_domain.test.js
-- [ ] T016 [US1] Add user-approved enqueue, privileged enqueue without approval returning denied/user-action-required before provider work starts, side-effect-free list/inspect, queued/running state, no-owner, unavailable, and validation-failed tests in tests/js/jobs_domain.test.js
-- [ ] T017 [US1] Add determinate progress, indeterminate progress, stale progress after terminal state, completion, and safe result summary tests in tests/js/jobs_domain.test.js
-- [ ] T018 [P] [US1] Add Capability Inspector jobs provider/progress/current-job rendering tests in tests/js/capability_inspector_render.test.js
+- [X] T015 [US1] Add provider registration, re-registration idempotence, unavailable/degraded provider, and incompatible provider tests in tests/js/jobs_domain.test.js
+- [X] T016 [US1] Add user-approved enqueue, privileged enqueue without approval returning denied/user-action-required before provider work starts, side-effect-free list/inspect, queued/running state, no-owner, unavailable, and validation-failed tests in tests/js/jobs_domain.test.js
+- [X] T017 [US1] Add determinate progress, indeterminate progress, stale progress after terminal state, completion, and safe result summary tests in tests/js/jobs_domain.test.js
+- [X] T018 [P] [US1] Add Capability Inspector jobs provider/progress/current-job rendering tests in tests/js/capability_inspector_render.test.js
 
 ### Implementation for User Story 1
 
-- [ ] T019 [US1] Implement `register-provider`, `unregister-provider`, `list-providers`, provider validation, and idempotent provider updates in static/capabilities/jobs.js
-- [ ] T020 [US1] Implement `enqueue` validation for one compatible provider, explicit user-action or approved-continuation authorization before provider dispatch, provider availability, provider operation dispatch, job creation, queued/running state, and denied/user-action-required/no-owner/no-handler/unavailable outcomes in static/capabilities/jobs.js
-- [ ] T021 [US1] Implement side-effect-free `list` and `inspect` command summaries for providers, jobs, progress, attempts, actions, timestamps, and safe reasons without invoking provider work callbacks in static/capabilities/jobs.js
-- [ ] T022 [US1] Implement provider progress and log update ingestion with determinate, indeterminate, step-only, decreasing-progress, and stale-after-terminal handling in static/capabilities/jobs.js
-- [ ] T023 [US1] Implement provider completion and failure result normalization with terminal outcomes, retryability, result summaries, and active-state cleanup in static/capabilities/jobs.js
-- [ ] T024 [US1] Emit `jobs:provider-registered`, `jobs:queued`, `jobs:started`, `jobs:progress`, `jobs:log`, `jobs:completed`, and `jobs:failed` lifecycle events in static/capabilities/jobs.js
-- [ ] T025 [US1] Render jobs provider cards, active/queued jobs, progress, action availability, and recent outcomes in plugins/capability_inspector/screen.js
-- [ ] T026 [US1] Load and smoke-check jobs host script ordering with index integration in static/index.html
+- [X] T019 [US1] Implement `register-provider`, `unregister-provider`, `list-providers`, provider validation, and idempotent provider updates in static/capabilities/jobs.js
+- [X] T020 [US1] Implement `enqueue` validation for one compatible provider, explicit user-action or approved-continuation authorization before provider dispatch, provider availability, provider operation dispatch, job creation, queued/running state, and denied/user-action-required/no-owner/no-handler/unavailable outcomes in static/capabilities/jobs.js
+- [X] T021 [US1] Implement side-effect-free `list` and `inspect` command summaries for providers, jobs, progress, attempts, actions, timestamps, and safe reasons without invoking provider work callbacks in static/capabilities/jobs.js
+- [X] T022 [US1] Implement provider progress and log update ingestion with determinate, indeterminate, step-only, decreasing-progress, and stale-after-terminal handling in static/capabilities/jobs.js
+- [X] T023 [US1] Implement provider completion and failure result normalization with terminal outcomes, retryability, result summaries, and active-state cleanup in static/capabilities/jobs.js
+- [X] T024 [US1] Emit `jobs:provider-registered`, `jobs:queued`, `jobs:started`, `jobs:progress`, `jobs:log`, `jobs:completed`, and `jobs:failed` lifecycle events in static/capabilities/jobs.js
+- [X] T025 [US1] Render jobs provider cards, active/queued jobs, progress, action availability, and recent outcomes in plugins/capability_inspector/screen.js
+- [X] T026 [US1] Load and smoke-check jobs host script ordering with index integration in static/index.html
 
 **Checkpoint**: User Story 1 is independently functional; a single provider can enqueue, progress, complete/fail, and appear in diagnostics and inspector.
 
@@ -81,20 +81,20 @@
 
 ### Tests for User Story 2
 
-- [ ] T027 [US2] Add queued cancel, running cancellation-requested, provider terminal after cancellation, late cancel stale, and unsupported cancel tests in tests/js/jobs_domain.test.js
-- [ ] T028 [US2] Add pause/resume supported, unsupported pause/resume, terminal pause/resume stale, and same-job-identity tests in tests/js/jobs_domain.test.js
-- [ ] T029 [US2] Add retryable failed/cancelled job, linked attempt, approved-continuation scope, widened-scope denial, and concurrent retry tests in tests/js/jobs_domain.test.js
-- [ ] T030 [P] [US2] Add inspector tests for cancellation-requested, paused, retryable terminal jobs, and linked attempts in tests/js/capability_inspector_render.test.js
+- [X] T027 [US2] Add queued cancel, running cancellation-requested, provider terminal after cancellation, late cancel stale, and unsupported cancel tests in tests/js/jobs_domain.test.js
+- [X] T028 [US2] Add pause/resume supported, unsupported pause/resume, terminal pause/resume stale, and same-job-identity tests in tests/js/jobs_domain.test.js
+- [X] T029 [US2] Add retryable failed/cancelled job, linked attempt, approved-continuation scope, widened-scope denial, and concurrent retry tests in tests/js/jobs_domain.test.js
+- [X] T030 [P] [US2] Add inspector tests for cancellation-requested, paused, retryable terminal jobs, and linked attempts in tests/js/capability_inspector_render.test.js
 
 ### Implementation for User Story 2
 
-- [ ] T031 [US2] Implement `cancel` command for queued immediate cancellation, running cancellation-requested, unsupported-operation, stale terminal, and provider failure outcomes in static/capabilities/jobs.js
-- [ ] T032 [US2] Implement `pause` command with provider action checks, paused state, unsupported-operation, stale terminal, and safe reason outcomes in static/capabilities/jobs.js
-- [ ] T033 [US2] Implement `resume` command returning paused jobs to queued/running state with the same job identity in static/capabilities/jobs.js
-- [ ] T034 [US2] Implement `retry` command with terminal-state checks, retryability, one active retry attempt, linked attempts, approved-continuation scope, and retry-started outcomes in static/capabilities/jobs.js
-- [ ] T035 [US2] Implement approval scope matching for provider, job type, target, requester, and inputs in static/capabilities/jobs.js
-- [ ] T036 [US2] Emit `jobs:cancellation-requested`, `jobs:cancelled`, `jobs:paused`, `jobs:resumed`, and `jobs:retried` events in static/capabilities/jobs.js
-- [ ] T037 [US2] Update Capability Inspector jobs rendering for cancellation state, pause/resume actions, retry action, and attempt history in plugins/capability_inspector/screen.js
+- [X] T031 [US2] Implement `cancel` command for queued immediate cancellation, running cancellation-requested, unsupported-operation, stale terminal, and provider failure outcomes in static/capabilities/jobs.js
+- [X] T032 [US2] Implement `pause` command with provider action checks, paused state, unsupported-operation, stale terminal, and safe reason outcomes in static/capabilities/jobs.js
+- [X] T033 [US2] Implement `resume` command returning paused jobs to queued/running state with the same job identity in static/capabilities/jobs.js
+- [X] T034 [US2] Implement `retry` command with terminal-state checks, retryability, one active retry attempt, linked attempts, approved-continuation scope, and retry-started outcomes in static/capabilities/jobs.js
+- [X] T035 [US2] Implement approval scope matching for provider, job type, target, requester, and inputs in static/capabilities/jobs.js
+- [X] T036 [US2] Emit `jobs:cancellation-requested`, `jobs:cancelled`, `jobs:paused`, `jobs:resumed`, and `jobs:retried` events in static/capabilities/jobs.js
+- [X] T037 [US2] Update Capability Inspector jobs rendering for cancellation state, pause/resume actions, retry action, and attempt history in plugins/capability_inspector/screen.js
 
 **Checkpoint**: User Story 2 is independently functional; all job control actions produce explicit outcomes and keep job state truthful.
 
@@ -108,22 +108,22 @@
 
 ### Tests for User Story 3
 
-- [ ] T038 [US3] Add exactly-one-provider auto-select, multiple-provider provider-selection-required, selected/default provider, unavailable selection, and explicit provider tests in tests/js/jobs_scheduling.test.js
-- [ ] T039 [US3] Add provider capacity, queued blocked reason, user-approved-before-background priority, FIFO within priority, and no overrun tests in tests/js/jobs_scheduling.test.js
-- [ ] T040 [US3] Add provider disappearance, provider-unavailable/orphaned state, provider rehydration no duplicates, and incompatible version tests in tests/js/jobs_scheduling.test.js
-- [ ] T041 [US3] Add reload recovery tests for persisted recoverable queued/running/paused job references, non-recoverable orphan/provider-unavailable jobs, stale persisted reference cleanup, and terminal preservation in tests/js/jobs_scheduling.test.js
-- [ ] T042 [P] [US3] Add selected/default provider persistence fallback tests in tests/js/jobs_scheduling.test.js
+- [X] T038 [US3] Add exactly-one-provider auto-select, multiple-provider provider-selection-required, selected/default provider, unavailable selection, and explicit provider tests in tests/js/jobs_scheduling.test.js
+- [X] T039 [US3] Add provider capacity, queued blocked reason, user-approved-before-background priority, FIFO within priority, and no overrun tests in tests/js/jobs_scheduling.test.js
+- [X] T040 [US3] Add provider disappearance, provider-unavailable/orphaned state, provider rehydration no duplicates, and incompatible version tests in tests/js/jobs_scheduling.test.js
+- [X] T041 [US3] Add reload recovery tests for persisted recoverable queued/running/paused job references, non-recoverable orphan/provider-unavailable jobs, stale persisted reference cleanup, and terminal preservation in tests/js/jobs_scheduling.test.js
+- [X] T042 [P] [US3] Add selected/default provider persistence fallback tests in tests/js/jobs_scheduling.test.js
 
 ### Implementation for User Story 3
 
-- [ ] T043 [US3] Implement selected/default provider state, localStorage persistence with in-memory fallback, and provider-selection-required logic in static/capabilities/jobs.js
-- [ ] T044 [US3] Implement scheduler capacity checks, queued blocked reasons, user-approved-interactive priority before background-maintenance, and FIFO ordering within priority in static/capabilities/jobs.js
-- [ ] T045 [US3] Implement start-next scheduling after enqueue, completion, cancellation, provider availability change, and resume in static/capabilities/jobs.js
-- [ ] T046 [US3] Implement provider disappearance and incompatible-provider handling that marks affected jobs provider-unavailable or orphaned with safe reasons in static/capabilities/jobs.js
-- [ ] T047 [US3] Implement provider rehydration and recoverable job reconciliation without duplicating providers, active jobs, terminal jobs, or attempts in static/capabilities/jobs.js
-- [ ] T048 [US3] Implement reload recovery hooks that persist only redaction-safe provider-declared recoverable queued/running/paused job references, restore them on reload, clean stale references, and mark non-recoverable jobs orphan/provider-unavailable in static/capabilities/jobs.js
-- [ ] T049 [US3] Emit `jobs:provider-unavailable` and `jobs:orphaned` events and scheduling-related queued/started events in static/capabilities/jobs.js
-- [ ] T050 [US3] Update Capability Inspector jobs rendering for provider selection, capacity/current load, queued blocked reason, priority, and recovery status in plugins/capability_inspector/screen.js
+- [X] T043 [US3] Implement selected/default provider state, localStorage persistence with in-memory fallback, and provider-selection-required logic in static/capabilities/jobs.js
+- [X] T044 [US3] Implement scheduler capacity checks, queued blocked reasons, user-approved-interactive priority before background-maintenance, and FIFO ordering within priority in static/capabilities/jobs.js
+- [X] T045 [US3] Implement start-next scheduling after enqueue, completion, cancellation, provider availability change, and resume in static/capabilities/jobs.js
+- [X] T046 [US3] Implement provider disappearance and incompatible-provider handling that marks affected jobs provider-unavailable or orphaned with safe reasons in static/capabilities/jobs.js
+- [X] T047 [US3] Implement provider rehydration and recoverable job reconciliation without duplicating providers, active jobs, terminal jobs, or attempts in static/capabilities/jobs.js
+- [X] T048 [US3] Implement reload recovery hooks that persist only redaction-safe provider-declared recoverable queued/running/paused job references, restore them on reload, clean stale references, and mark non-recoverable jobs orphan/provider-unavailable in static/capabilities/jobs.js
+- [X] T049 [US3] Emit `jobs:provider-unavailable` and `jobs:orphaned` events and scheduling-related queued/started events in static/capabilities/jobs.js
+- [X] T050 [US3] Update Capability Inspector jobs rendering for provider selection, capacity/current load, queued blocked reason, priority, and recovery status in plugins/capability_inspector/screen.js
 
 **Checkpoint**: User Story 3 is independently functional; providers can be selected, scheduled, recovered, and diagnosed without duplicate queues or over-capacity starts.
 
@@ -137,21 +137,21 @@
 
 ### Tests for User Story 4
 
-- [ ] T051 [US4] Add diagnostics schema, active/queued/paused/recent terminal grouping, all-active retention, five-terminal retention, and 50-entry history cap tests in tests/js/jobs_diagnostics.test.js
-- [ ] T052 [US4] Add redaction tests for paths, raw filenames, URLs, tokens, command lines, environment values, raw artifacts, media buffers, recordings, native handles, subprocess handles, and provider-private payloads in tests/js/jobs_diagnostics.test.js
-- [ ] T053 [US4] Add failure category tests for invalid-input, permission-denied, provider-unavailable, unsupported-operation, timeout, cancellation, external-dependency, storage, provider-failure, and unknown in tests/js/jobs_diagnostics.test.js
-- [ ] T054 [US4] Add compatibility bridge hit, legacy duplicate suppression, legacy queue/status/backend-route operations, and diagnostics-only bridge tests in tests/js/jobs_compat.test.js
-- [ ] T055 [P] [US4] Add inspector diagnostics tests for terminal jobs, safe failure category, bridge hits, retention limits, and redacted log messages in tests/js/capability_inspector_render.test.js
+- [X] T051 [US4] Add diagnostics schema, active/queued/paused/recent terminal grouping, all-active retention, five-terminal retention, and 50-entry history cap tests in tests/js/jobs_diagnostics.test.js
+- [X] T052 [US4] Add redaction tests for paths, raw filenames, URLs, tokens, command lines, environment values, raw artifacts, media buffers, recordings, native handles, subprocess handles, and provider-private payloads in tests/js/jobs_diagnostics.test.js
+- [X] T053 [US4] Add failure category tests for invalid-input, permission-denied, provider-unavailable, unsupported-operation, timeout, cancellation, external-dependency, storage, provider-failure, and unknown in tests/js/jobs_diagnostics.test.js
+- [X] T054 [US4] Add compatibility bridge hit, legacy duplicate suppression, legacy queue/status/backend-route operations, and diagnostics-only bridge tests in tests/js/jobs_compat.test.js
+- [X] T055 [P] [US4] Add inspector diagnostics tests for terminal jobs, safe failure category, bridge hits, retention limits, and redacted log messages in tests/js/capability_inspector_render.test.js
 
 ### Implementation for User Story 4
 
-- [ ] T056 [US4] Implement diagnostics payload `slopsmith.jobs.diagnostics.v1` with providers, selectedProviders, jobs, outcomes, bridgeHits, limits, and notes in static/capabilities/jobs.js
-- [ ] T057 [US4] Implement retention policy preserving all active jobs, at least five recent terminal jobs, and at most 50 progress/log entries per job within snapshot budget in static/capabilities/jobs.js
-- [ ] T058 [US4] Implement failure category normalization and safe retryability summaries for invalid input, permission denied, provider unavailable, unsupported operation, timeout, cancellation, external dependency, storage, provider failure, and unknown in static/capabilities/jobs.js
-- [ ] T059 [US4] Implement redaction/pseudonymization enforcement for exported diagnostics and local inspector snapshots in static/capabilities/jobs.js
-- [ ] T060 [US4] Implement `record-bridge-hit` command and bridge hit normalization for legacy plugin queue, status screen, backend route, progress poll, and update flow in static/capabilities/jobs.js
-- [ ] T061 [US4] Implement native-over-compatibility duplicate suppression for logical jobs shared by native providers and compatibility-backed legacy surfaces in static/capabilities/jobs.js
-- [ ] T062 [US4] Update Capability Inspector jobs rendering for recent terminal jobs, failure categories, retention notes, bridge hits, and redacted history in plugins/capability_inspector/screen.js
+- [X] T056 [US4] Implement diagnostics payload `slopsmith.jobs.diagnostics.v1` with providers, selectedProviders, jobs, outcomes, bridgeHits, limits, and notes in static/capabilities/jobs.js
+- [X] T057 [US4] Implement retention policy preserving all active jobs, at least five recent terminal jobs, and at most 50 progress/log entries per job within snapshot budget in static/capabilities/jobs.js
+- [X] T058 [US4] Implement failure category normalization and safe retryability summaries for invalid input, permission denied, provider unavailable, unsupported operation, timeout, cancellation, external dependency, storage, provider failure, and unknown in static/capabilities/jobs.js
+- [X] T059 [US4] Implement redaction/pseudonymization enforcement for exported diagnostics and local inspector snapshots in static/capabilities/jobs.js
+- [X] T060 [US4] Implement `record-bridge-hit` command and bridge hit normalization for legacy plugin queue, status screen, backend route, progress poll, and update flow in static/capabilities/jobs.js
+- [X] T061 [US4] Implement native-over-compatibility duplicate suppression for logical jobs shared by native providers and compatibility-backed legacy surfaces in static/capabilities/jobs.js
+- [X] T062 [US4] Update Capability Inspector jobs rendering for recent terminal jobs, failure categories, retention notes, bridge hits, and redacted history in plugins/capability_inspector/screen.js
 
 **Checkpoint**: User Story 4 is independently functional; support surfaces explain failures and migration bridges without leaking privileged data.
 
@@ -161,16 +161,16 @@
 
 **Purpose**: Documentation, migration guidance, validation, and cleanup across all stories.
 
-- [ ] T063 [P] Update jobs active-domain command/event/diagnostics guidance in docs/capability-domains.md
-- [ ] T064 [P] Update jobs migration status and removal gates in docs/capability-roadmap.md
-- [ ] T065 [P] Update jobs privileged provider-coordinator row and outcomes in docs/capability-safety-matrix.md
-- [ ] T066 [P] Add jobs provider/requester manifest and dispatch recipe in docs/capability-recipes.md
-- [ ] T067 [P] Add changelog entry for the jobs control plane in CHANGELOG.md
-- [ ] T068 Run syntax checks for static/capabilities.js, static/capabilities/jobs.js, and plugins/capability_inspector/screen.js
-- [ ] T069 Run focused JS validation with npm run test:js and confirm jobs tests pass in tests/js/jobs_domain.test.js, tests/js/jobs_scheduling.test.js, tests/js/jobs_diagnostics.test.js, tests/js/jobs_compat.test.js, and tests/js/capability_inspector_render.test.js
-- [ ] T070 Run focused pytest regression if diagnostics/plugin/redaction Python surfaces changed in tests/test_diagnostics_bundle.py, tests/test_diagnostics_redact.py, tests/test_plugins.py, and tests/test_plugin_runtime_idempotence.py
-- [ ] T071 Run browser console smoke after UI wiring with tests/browser/check-errors.spec.ts
-- [ ] T072 Verify quickstart scenarios and update any discovered validation notes in specs/009-jobs/quickstart.md
+- [X] T063 [P] Update jobs active-domain command/event/diagnostics guidance in docs/capability-domains.md
+- [X] T064 [P] Update jobs migration status and removal gates in docs/capability-roadmap.md
+- [X] T065 [P] Update jobs privileged provider-coordinator row and outcomes in docs/capability-safety-matrix.md
+- [X] T066 [P] Add jobs provider/requester manifest and dispatch recipe in docs/capability-recipes.md
+- [X] T067 [P] Add changelog entry for the jobs control plane in CHANGELOG.md
+- [X] T068 Run syntax checks for static/capabilities.js, static/capabilities/jobs.js, and plugins/capability_inspector/screen.js
+- [X] T069 Run focused JS validation with npm run test:js and confirm jobs tests pass in tests/js/jobs_domain.test.js, tests/js/jobs_scheduling.test.js, tests/js/jobs_diagnostics.test.js, tests/js/jobs_compat.test.js, and tests/js/capability_inspector_render.test.js
+- [X] T070 Run focused pytest regression if diagnostics/plugin/redaction Python surfaces changed in tests/test_diagnostics_bundle.py, tests/test_diagnostics_redact.py, tests/test_plugins.py, and tests/test_plugin_runtime_idempotence.py
+- [X] T071 Run browser console smoke after UI wiring with tests/browser/check-errors.spec.ts
+- [X] T072 Verify quickstart scenarios and update any discovered validation notes in specs/009-jobs/quickstart.md
 
 ---
 
diff --git a/static/capabilities.js b/static/capabilities.js
index 7e68c32..172fb34 100644
--- a/static/capabilities.js
+++ b/static/capabilities.js
@@ -72,9 +72,9 @@
     const OUTCOMES = new Set([
         'passed', 'transformed', 'handled', 'denied', 'degraded', 'failed',
         'short-circuited', 'overridden', 'no-owner', 'no-handler',
-        'unsupported-command', 'incompatible', 'incompatible-version',
+        'unsupported-command', 'unsupported-operation', 'incompatible', 'incompatible-version',
         'unavailable', 'provider-selection-required', 'user-action-required', 'no-target',
-        'stale', 'cancelled', 'stopped',
+        'stale', 'queued', 'validation-failed', 'cancelled', 'completed', 'timeout', 'retry-started', 'stopped',
     ]);
     const MAX_DECISIONS = 100;
     const MAX_SNAPSHOT_BYTES = 64 * 1024;
@@ -88,7 +88,6 @@
         'ui.player-panels',
         'ui.player-overlays',
         'plugins',
-        'jobs',
         'midi-control',
         'tempo-clock',
     ]);
@@ -110,6 +109,7 @@
         'audio-mix': Object.freeze({ lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Core-coordinated song route, fader, participant, and analyser inspection surface.' }),
         'audio-monitoring': Object.freeze({ lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Core-coordinated monitoring lifecycle, availability, consent, and bridge diagnostics.' }),
         library: Object.freeze({ lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Current local and plugin-provided library source selection and sync surface.' }),
+        jobs: Object.freeze({ lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Privileged provider-coordinator control plane for long-running work, scheduling, recovery, bridges, and redaction-safe diagnostics.' }),
         playback: Object.freeze({ lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Core-coordinated song transport, timing, loop, route, requester, bridge, and diagnostics surface.' }),
         pipeline: Object.freeze({ lifecycle: 'diagnostic', label: 'Graph controls', tone: 'info', summary: 'Capability graph operations: resolve, inspect, validate, and enable or disable participants.' }),
         stems: Object.freeze({ lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Core-coordinated stem automation, restore, manual override, and compatibility bridge surface backed by the active Stems provider.' }),
@@ -832,7 +832,7 @@
 
     function _finalOutcome(decisions) {
         if (!decisions.length) return 'degraded';
-        const terminal = decisions.find(d => ['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'cancelled', 'stopped'].includes(d.outcome));
+        const terminal = decisions.find(d => ['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'unsupported-operation', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'queued', 'validation-failed', 'cancelled', 'completed', 'timeout', 'retry-started', 'stopped'].includes(d.outcome));
         return terminal ? terminal.outcome : decisions[decisions.length - 1].outcome;
     }
 
@@ -986,7 +986,7 @@
                 commandContext.payload = decision.payload;
                 continue;
             }
-            if (['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'cancelled', 'stopped'].includes(decision.outcome)) break;
+            if (['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'unsupported-operation', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'queued', 'validation-failed', 'cancelled', 'completed', 'timeout', 'retry-started', 'stopped'].includes(decision.outcome)) break;
         }
         if (!decisions.length) {
             const reason = `No provider handled ${capabilityName}.${commandName}`;
@@ -1005,7 +1005,7 @@
             });
         }
         const outcome = _finalOutcome(decisions);
-        const terminalDecision = decisions.find(d => ['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'cancelled', 'stopped'].includes(d.outcome))
+        const terminalDecision = decisions.find(d => ['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'unsupported-operation', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'queued', 'validation-failed', 'cancelled', 'completed', 'timeout', 'retry-started', 'stopped'].includes(d.outcome))
             || decisions[decisions.length - 1];
         return {
             capability: capabilityName,
@@ -1317,13 +1317,19 @@
         if (result.outcome === 'no-handler') return 'no-handler';
         if (result.outcome === 'no-target') return 'no-target';
         if (result.outcome === 'unsupported-command') return 'unsupported-command';
+        if (result.outcome === 'unsupported-operation') return 'unsupported-operation';
         if (result.outcome === 'incompatible') return 'incompatible';
         if (result.outcome === 'incompatible-version') return 'incompatible-version';
         if (result.outcome === 'unavailable') return 'unavailable';
         if (result.outcome === 'provider-selection-required') return 'provider-selection-required';
         if (result.outcome === 'user-action-required') return 'user-action-required';
         if (result.outcome === 'stale') return 'stale';
+        if (result.outcome === 'queued') return 'queued';
+        if (result.outcome === 'validation-failed') return 'validation-failed';
         if (result.outcome === 'cancelled') return 'cancelled';
+        if (result.outcome === 'completed') return 'completed';
+        if (result.outcome === 'timeout') return 'timeout';
+        if (result.outcome === 'retry-started') return 'retry-started';
         if (result.outcome === 'stopped') return 'stopped';
         if (result.outcome === 'denied' || result.outcome === 'short-circuited') return 'blocked';
         if (result.outcome === 'failed') return 'error';
diff --git a/static/capabilities/jobs.js b/static/capabilities/jobs.js
new file mode 100644
index 0000000..caadeaf
--- /dev/null
+++ b/static/capabilities/jobs.js
@@ -0,0 +1,1127 @@
+// Core jobs capability domain host.
+(function () {
+    'use strict';
+
+    window.slopsmith = window.slopsmith || {};
+    const capabilities = window.slopsmith.capabilities;
+    if (!capabilities || capabilities.version !== 1) return;
+    if (window.slopsmith.jobs && window.slopsmith.jobs.version === 1) return;
+
+    const SCHEMA = 'slopsmith.jobs.diagnostics.v1';
+    const OWNER_ID = 'core.jobs';
+    const SELECTED_PROVIDER_STORAGE_KEY = 'slopsmith.jobs.selectedProviders.v1';
+    const RECOVERY_STORAGE_KEY = 'slopsmith.jobs.recoverableRefs.v1';
+    const MAX_REASON = 240;
+    const MAX_LABEL = 120;
+    const MAX_HISTORY_PER_JOB = 50;
+    const MAX_TERMINAL_JOBS = 20;
+    const MIN_TERMINAL_RETAINED = 5;
+    const MAX_OUTCOMES = 100;
+    const MAX_BRIDGES = 100;
+    const SNAPSHOT_BUDGET_BYTES = 64 * 1024;
+
+    const STATES = Object.freeze({
+        QUEUED: 'queued',
+        RUNNING: 'running',
+        PAUSED: 'paused',
+        CANCELLATION_REQUESTED: 'cancellation-requested',
+        CANCELLED: 'cancelled',
+        COMPLETED: 'completed',
+        FAILED: 'failed',
+        PROVIDER_UNAVAILABLE: 'provider-unavailable',
+        ORPHANED: 'orphaned',
+    });
+    const TERMINAL_STATES = new Set([STATES.CANCELLED, STATES.COMPLETED, STATES.FAILED, STATES.PROVIDER_UNAVAILABLE, STATES.ORPHANED]);
+    const ACTIVE_STATES = new Set([STATES.QUEUED, STATES.RUNNING, STATES.PAUSED, STATES.CANCELLATION_REQUESTED]);
+    const OUTCOMES = new Set([
+        'handled', 'queued', 'denied', 'user-action-required', 'unavailable', 'no-owner', 'no-handler', 'no-target',
+        'unsupported-command', 'unsupported-operation', 'incompatible', 'incompatible-version', 'provider-selection-required',
+        'validation-failed', 'stale', 'cancelled', 'completed', 'failed', 'timeout', 'retry-started',
+    ]);
+    const ACTIONS = new Set(['enqueue', 'inspect', 'cancel', 'pause', 'resume', 'retry', 'recover']);
+    const PRIORITIES = new Set(['user-approved-interactive', 'background-maintenance']);
+    const AVAILABILITY = new Set(['available', 'unavailable', 'degraded', 'disabled', 'incompatible']);
+    const FAILURE_CATEGORIES = new Set(['invalid-input', 'permission-denied', 'provider-unavailable', 'unsupported-operation', 'timeout', 'cancellation', 'external-dependency', 'storage', 'provider-failure', 'unknown']);
+    const BRIDGE_IDS = new Set(['jobs.legacy-plugin-queue', 'jobs.legacy-status-screen', 'jobs.legacy-backend-route', 'jobs.legacy-progress-poll', 'jobs.legacy-update-flow']);
+    const RAW_KEY_RE = /(^|_)(path|filename|file|url|token|secret|password|apiKey|api_key|command|commandLine|env|environment|artifact|media|audio|buffer|recording|handle|native|subprocess|payload|private|raw)(_|$)/i;
+
+    let sequence = 0;
+    let outcomeSequence = 0;
+    const providers = new Map();
+    const selectedProviders = new Map();
+    const jobs = new Map();
+    const terminalJobIds = [];
+    const outcomes = [];
+    const bridgeHits = [];
+    const pendingRecoverableRefs = new Map();
+    const memoryStorage = new Map();
+
+    function _now() { return new Date().toISOString(); }
+
+    function _id(prefix) {
+        sequence += 1;
+        return `${prefix}-${sequence}`;
+    }
+
+    function _string(value, fallback = '') {
+        const normalized = String(value == null ? '' : value).trim();
+        return normalized || fallback;
+    }
+
+    function _number(value, fallback = null) {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : fallback;
+    }
+
+    function _bool(value, fallback = false) {
+        if (value === true || value === false) return value;
+        return fallback;
+    }
+
+    function _plainObject(value) {
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    }
+
+    function _strings(value) {
+        const out = [];
+        const seen = new Set();
+        for (const item of Array.isArray(value) ? value : []) {
+            const normalized = _string(item);
+            if (!normalized || seen.has(normalized)) continue;
+            seen.add(normalized);
+            out.push(normalized);
+        }
+        return out;
+    }
+
+    function _hash(value) {
+        const input = _string(value, 'unknown');
+        let h = 2166136261;
+        for (let i = 0; i < input.length; i += 1) {
+            h ^= input.charCodeAt(i);
+            h = Math.imul(h, 16777619);
+        }
+        return (h >>> 0).toString(36);
+    }
+
+    function _redactString(value) {
+        return _string(value)
+            .replace(/\/Users\/[^\s/]+(?:\/[^\s]*)?/g, '[path]')
+            .replace(/[A-Za-z]:\\[^\s]+/g, '[path]')
+            .replace(/https?:\/\/[^\s?#]+[^\s]*/gi, '[url]')
+            .replace(/\b(token|secret|password|api[_-]?key)=([^\s&]+)/gi, '$1=[redacted]')
+            .replace(/\b[A-Za-z0-9._%+-]+\.(psarc|sloppak|wav|mp3|ogg|flac|zip|sqlite|db)\b/gi, '[file]')
+            .replace(/\b(raw[-_ ]?artifact|raw[-_ ]?audio|audio[-_ ]?buffer|sample[s]?|waveform[s]?|recording[s]?|subprocess|native[-_ ]?handle|process[-_ ]?handle)\b/gi, '[private]')
+            .replace(/\b(?:ffmpeg|vgmstream|rscli|python|node|uvicorn)\s+[^\n\r]*/gi, '[command]');
+    }
+
+    function _safeText(value, fallback = '', limit = MAX_REASON) {
+        const normalized = _redactString(value).replace(/\s+/g, ' ').trim();
+        return (normalized || fallback).slice(0, limit);
+    }
+
+    function _safeId(value, fallback = 'unknown') {
+        return _string(value, fallback).replace(/[^A-Za-z0-9_.:-]+/g, '-').slice(0, 96) || fallback;
+    }
+
+    function _safeValue(value, depth = 0) {
+        if (typeof value === 'string') return _safeText(value);
+        if (value == null || typeof value === 'number' || typeof value === 'boolean') return value;
+        if (typeof value === 'function') return undefined;
+        if (depth > 6) return '[truncated]';
+        if (Array.isArray(value)) return value.slice(0, 30).map(item => _safeValue(item, depth + 1)).filter(item => item !== undefined);
+        if (typeof value === 'object') {
+            const out = {};
+            for (const [key, item] of Object.entries(value).slice(0, 40)) {
+                if (RAW_KEY_RE.test(key)) continue;
+                const safeItem = _safeValue(item, depth + 1);
+                if (safeItem !== undefined) out[_safeText(key, 'field', 80)] = safeItem;
+            }
+            return out;
+        }
+        return '';
+    }
+
+    function _clone(value) {
+        try { return JSON.parse(JSON.stringify(value)); }
+        catch (_) { return null; }
+    }
+
+    function _storageGet(key) {
+        try {
+            if (window.localStorage && typeof window.localStorage.getItem === 'function') return window.localStorage.getItem(key);
+        } catch (_) {}
+        return memoryStorage.has(key) ? memoryStorage.get(key) : null;
+    }
+
+    function _storageSet(key, value) {
+        const normalized = String(value == null ? '' : value);
+        try {
+            if (window.localStorage && typeof window.localStorage.setItem === 'function') {
+                window.localStorage.setItem(key, normalized);
+                return 'available';
+            }
+        } catch (_) {}
+        memoryStorage.set(key, normalized);
+        return 'memory-fallback';
+    }
+
+    function _storageRemove(key) {
+        try {
+            if (window.localStorage && typeof window.localStorage.removeItem === 'function') window.localStorage.removeItem(key);
+        } catch (_) {}
+        memoryStorage.delete(key);
+    }
+
+    function _readJsonStorage(key, fallback) {
+        const raw = _storageGet(key);
+        if (!raw) return fallback;
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed == null ? fallback : parsed;
+        } catch (_) {
+            return fallback;
+        }
+    }
+
+    function _writeJsonStorage(key, value) {
+        return _storageSet(key, JSON.stringify(value));
+    }
+
+    function _normalizeCapacity(value) {
+        const source = _plainObject(value);
+        return {
+            maxRunning: Math.max(0, _number(source.maxRunning, 1) ?? 1),
+            maxQueued: Math.max(0, _number(source.maxQueued, 100) ?? 100),
+        };
+    }
+
+    function _normalizeRecoverySupport(value) {
+        const source = _plainObject(value);
+        return {
+            queued: !!source.queued,
+            running: !!source.running,
+            paused: !!source.paused,
+        };
+    }
+
+    function _normalizeProvider(raw) {
+        const source = _plainObject(raw);
+        const providerId = _safeId(source.providerId || source.id, '');
+        const jobTypes = _strings(source.jobTypes || source.supportedJobTypes);
+        const actions = _strings(source.actions || source.supportedActions).filter(action => ACTIONS.has(action));
+        const availability = AVAILABILITY.has(source.availability) ? source.availability : 'available';
+        return {
+            providerId,
+            pluginId: _safeId(source.pluginId || source.ownerPluginId || providerId, providerId || 'unknown'),
+            label: _safeText(source.label || source.safeLabel || providerId, providerId, MAX_LABEL),
+            jobTypes,
+            actions: actions.length ? actions : ['enqueue', 'inspect'],
+            availability,
+            capacity: _normalizeCapacity(source.capacity),
+            currentLoad: { running: 0, queued: 0 },
+            selectionEligible: source.selectionEligible !== false,
+            recoverySupport: _normalizeRecoverySupport(source.recoverySupport),
+            safeReason: source.safeReason || source.reason ? _safeText(source.safeReason || source.reason) : null,
+            operationHandlers: _plainObject(source.operationHandlers || source.handlers || source.operationsHandlers),
+            version: _number(source.version, 1) || 1,
+            logicalProviderKey: _safeId(source.logicalProviderKey || providerId, providerId || 'unknown'),
+            lastSeenAt: _now(),
+        };
+    }
+
+    function _providerSummary(provider) {
+        const load = _providerLoad(provider.providerId);
+        return {
+            providerId: provider.providerId,
+            pluginId: provider.pluginId,
+            label: provider.label,
+            jobTypes: provider.jobTypes.slice(),
+            actions: provider.actions.slice(),
+            availability: provider.availability,
+            capacity: _clone(provider.capacity),
+            currentLoad: load,
+            recoverySupport: _clone(provider.recoverySupport),
+            safeReason: provider.safeReason || null,
+            lastSeenAt: provider.lastSeenAt,
+        };
+    }
+
+    function _targetRef(target) {
+        const source = _plainObject(target);
+        const seed = source.targetRef || source.safeRef || source.safeFingerprint || source.id || source.kind || source.name || 'unknown';
+        if (source.targetRef && /^[A-Za-z0-9_.:-]+$/.test(String(source.targetRef))) return String(source.targetRef).slice(0, 96);
+        return `target-${_hash(seed)}`;
+    }
+
+    function _inputFingerprint(inputs) {
+        const source = _plainObject(inputs);
+        return _safeId(source.safeFingerprint || source.fingerprint || _hash(JSON.stringify(_safeValue(source))), 'input-unknown');
+    }
+
+    function _approvalScope(args, providerId) {
+        const source = _plainObject(args);
+        return {
+            providerId,
+            jobType: _safeId(source.jobType, 'unknown'),
+            targetRef: _targetRef(source.target),
+            requesterId: _safeId(source.requesterId || source.requester || source.source, 'unknown'),
+            inputFingerprint: _inputFingerprint(source.inputs),
+        };
+    }
+
+    function _scopeKey(scope) {
+        return [scope.providerId, scope.jobType, scope.targetRef, scope.requesterId, scope.inputFingerprint].join('|');
+    }
+
+    function _priority(value) {
+        return PRIORITIES.has(value) ? value : 'user-approved-interactive';
+    }
+
+    function _priorityRank(job) {
+        return job.priority === 'user-approved-interactive' ? 0 : 1;
+    }
+
+    function _actionsAvailable(job) {
+        if (!job || TERMINAL_STATES.has(job.state)) return job && job.retryable ? ['retry'] : [];
+        const provider = providers.get(job.providerId);
+        const providerActions = provider ? provider.actions : [];
+        const actions = ['inspect'];
+        if (job.state === STATES.QUEUED || job.state === STATES.RUNNING || job.state === STATES.PAUSED) {
+            if (providerActions.includes('cancel') || job.state === STATES.QUEUED) actions.push('cancel');
+        }
+        if (job.state === STATES.RUNNING && providerActions.includes('pause')) actions.push('pause');
+        if (job.state === STATES.PAUSED && providerActions.includes('resume')) actions.push('resume');
+        return actions;
+    }
+
+    function _newAttempt(job, state) {
+        return {
+            attemptId: _id('attempt'),
+            jobId: job.jobId,
+            attemptNumber: job.attempts.length + 1,
+            providerId: job.providerId,
+            approvalScopeId: job.approvalScopeKey,
+            state,
+            startedAt: state === STATES.RUNNING ? _now() : null,
+            updatedAt: _now(),
+            terminalAt: null,
+            terminalOutcome: null,
+        };
+    }
+
+    function _newJob(args, providerId) {
+        const now = _now();
+        const scope = _approvalScope(args, providerId);
+        const job = {
+            jobId: _safeId(args.jobId, '') || _id('job'),
+            logicalJobKey: _safeId(args.logicalJobKey || '', ''),
+            jobType: _safeId(args.jobType, 'unknown'),
+            providerId,
+            requesterId: scope.requesterId,
+            targetRef: scope.targetRef,
+            inputFingerprint: scope.inputFingerprint,
+            approvalScope: scope,
+            approvalScopeKey: _scopeKey(scope),
+            authorization: _safeId(args.authorization || 'none', 'none'),
+            priority: _priority(args.priority || (args.authorization === 'background' ? 'background-maintenance' : 'user-approved-interactive')),
+            safeLabel: _safeText(args.safeLabel || args.label || `${args.jobType || 'Job'} job`, 'Job', MAX_LABEL),
+            state: STATES.QUEUED,
+            progress: { mode: 'indeterminate', percent: null, step: '', message: '', updatedAt: now },
+            attempts: [],
+            history: [],
+            retryable: false,
+            safeReason: null,
+            terminalOutcome: null,
+            bridgeSource: args.bridgeSource ? _safeText(args.bridgeSource, '', 80) : null,
+            createdAt: now,
+            queuedAt: now,
+            startedAt: null,
+            updatedAt: now,
+            terminalAt: null,
+        };
+        job.attempts.push(_newAttempt(job, STATES.QUEUED));
+        return job;
+    }
+
+    function _jobSummary(job, options = {}) {
+        return {
+            jobId: job.jobId,
+            jobType: job.jobType,
+            providerId: job.providerId,
+            requesterId: job.requesterId,
+            targetRef: job.targetRef,
+            inputFingerprint: job.inputFingerprint,
+            state: job.state,
+            priority: job.priority,
+            safeLabel: job.safeLabel,
+            progress: _clone(job.progress),
+            actionsAvailable: _actionsAvailable(job),
+            retryable: !!job.retryable,
+            attempts: job.attempts.map(attempt => ({
+                attemptId: attempt.attemptId,
+                attemptNumber: attempt.attemptNumber,
+                state: attempt.state,
+                terminalOutcome: attempt.terminalOutcome,
+            })),
+            terminalOutcome: job.terminalOutcome ? _clone(job.terminalOutcome) : null,
+            safeReason: job.safeReason || null,
+            timestamps: {
+                createdAt: job.createdAt,
+                queuedAt: job.queuedAt,
+                startedAt: job.startedAt,
+                updatedAt: job.updatedAt,
+                terminalAt: job.terminalAt,
+            },
+            history: options.includeHistory === false ? [] : job.history.slice(-MAX_HISTORY_PER_JOB).map(entry => _clone(entry)),
+            bridgeSource: job.bridgeSource || null,
+        };
+    }
+
+    function _providerLoad(providerId) {
+        let running = 0;
+        let queued = 0;
+        for (const job of jobs.values()) {
+            if (job.providerId !== providerId) continue;
+            if (job.state === STATES.RUNNING || job.state === STATES.CANCELLATION_REQUESTED) running += 1;
+            if (job.state === STATES.QUEUED) queued += 1;
+        }
+        return { running, queued };
+    }
+
+    function _rememberOutcome(operation, status, details = {}) {
+        const normalized = OUTCOMES.has(status) ? status : 'handled';
+        const entry = {
+            seq: ++outcomeSequence,
+            operation: _safeText(operation, 'operation', 80),
+            jobId: details.jobId || null,
+            providerId: details.providerId || null,
+            requesterId: details.requesterId || null,
+            status: normalized,
+            category: details.category || null,
+            safeReason: details.safeReason ? _safeText(details.safeReason) : null,
+            timestamp: _now(),
+        };
+        outcomes.push(entry);
+        while (outcomes.length > MAX_OUTCOMES) outcomes.shift();
+        _contributeDiagnostics();
+        return entry;
+    }
+
+    function _history(job, kind, message, extra = {}) {
+        if (!job) return null;
+        const entry = {
+            entryId: `${job.jobId}-entry-${job.history.length + 1}`,
+            jobId: job.jobId,
+            attemptId: job.attempts[job.attempts.length - 1]?.attemptId || null,
+            kind: _safeId(kind, 'event'),
+            message: _safeText(message),
+            timestamp: _now(),
+            ..._safeValue(extra),
+        };
+        job.history.push(entry);
+        while (job.history.length > MAX_HISTORY_PER_JOB) job.history.shift();
+        job.updatedAt = _now();
+        _persistRecoverableRefs();
+        _contributeDiagnostics();
+        return entry;
+    }
+
+    function _emitJobs(event, payload = {}) {
+        if (capabilities && typeof capabilities.emitEvent === 'function') capabilities.emitEvent('jobs', event, _safeValue(payload));
+    }
+
+    function _result(outcome, payload = {}, reason = '') {
+        return { outcome, payload: _safeValue(payload), reason: reason ? _safeText(reason) : undefined };
+    }
+
+    function _handled(payload = {}) { return _result('handled', payload); }
+
+    function _callProvider(provider, operation, payload) {
+        const handlers = provider && provider.operationHandlers ? provider.operationHandlers : {};
+        const handler = handlers[operation] || handlers[operation.replace(/^job\./, '')];
+        if (typeof handler !== 'function') return null;
+        return handler(_safeValue(payload));
+    }
+
+    function _compatibleProviders(jobType) {
+        return Array.from(providers.values()).filter(provider => {
+            if (!provider.jobTypes.includes(jobType)) return false;
+            if (provider.availability === 'disabled' || provider.availability === 'incompatible') return false;
+            return true;
+        });
+    }
+
+    function _providerCanRun(provider) {
+        return provider && (provider.availability === 'available' || provider.availability === 'degraded');
+    }
+
+    function _resolveProvider(args) {
+        const jobType = _safeId(args.jobType, '');
+        if (!jobType) return { outcome: 'validation-failed', reason: 'jobType is required' };
+        const explicitProviderId = _safeId(args.providerId || '', '');
+        const compatible = _compatibleProviders(jobType);
+        if (explicitProviderId) {
+            const explicit = providers.get(explicitProviderId);
+            if (!explicit) return { outcome: 'no-owner', reason: `Provider ${explicitProviderId} is not registered` };
+            if (!explicit.jobTypes.includes(jobType)) return { outcome: 'no-handler', reason: `Provider ${explicitProviderId} does not handle ${jobType}` };
+            if (explicit.availability === 'incompatible') return { outcome: 'incompatible-version', reason: explicit.safeReason || 'Provider is incompatible' };
+            if (!_providerCanRun(explicit)) return { outcome: 'unavailable', reason: explicit.safeReason || 'Provider unavailable' };
+            return { provider: explicit };
+        }
+        const runnable = compatible.filter(_providerCanRun);
+        if (!compatible.length) return { outcome: 'no-owner', reason: `No provider handles ${jobType}` };
+        if (!runnable.length) return { outcome: 'unavailable', reason: `No available provider handles ${jobType}` };
+        if (runnable.length === 1) return { provider: runnable[0] };
+        const selected = selectedProviders.get(jobType);
+        if (selected && runnable.some(provider => provider.providerId === selected.providerId)) return { provider: providers.get(selected.providerId) };
+        return { outcome: 'provider-selection-required', reason: `Multiple providers handle ${jobType}` };
+    }
+
+    function _authorizationAllowed(args, providerId) {
+        if (args.privileged === false) return true;
+        if (args.authorization === 'user-action') return true;
+        if (args.authorization === 'approved-continuation') {
+            const scope = _approvalScope(args, providerId);
+            return _scopeKey(scope) === _safeId(args.approvalScopeKey || args.approvalKey || '', '');
+        }
+        return false;
+    }
+
+    function _findDuplicateJob(args, providerId) {
+        const logicalJobKey = _safeId(args.logicalJobKey || '', '');
+        if (!logicalJobKey) return null;
+        for (const job of jobs.values()) {
+            if (job.logicalJobKey === logicalJobKey && job.providerId === providerId && !TERMINAL_STATES.has(job.state)) return job;
+        }
+        return null;
+    }
+
+    function _persistSelectedProviders() {
+        _writeJsonStorage(SELECTED_PROVIDER_STORAGE_KEY, Array.from(selectedProviders.values()).map(item => _safeValue(item)));
+    }
+
+    function _loadSelectedProviders() {
+        const stored = _readJsonStorage(SELECTED_PROVIDER_STORAGE_KEY, []);
+        for (const item of Array.isArray(stored) ? stored : []) {
+            const jobType = _safeId(item && item.jobType, '');
+            const providerId = _safeId(item && item.providerId, '');
+            if (!jobType || !providerId) continue;
+            selectedProviders.set(jobType, { jobType, providerId, source: _safeId(item.source || 'stored', 'stored'), updatedAt: item.updatedAt || _now(), restored: true });
+        }
+    }
+
+    function _recoverableRef(job) {
+        const provider = providers.get(job.providerId);
+        if (!provider || !ACTIVE_STATES.has(job.state)) return null;
+        const recoveryState = job.state === STATES.CANCELLATION_REQUESTED ? STATES.RUNNING : job.state;
+        if (!provider.recoverySupport[recoveryState]) return null;
+        return {
+            jobId: job.jobId,
+            logicalJobKey: job.logicalJobKey || '',
+            jobType: job.jobType,
+            providerId: job.providerId,
+            requesterId: job.requesterId,
+            targetRef: job.targetRef,
+            inputFingerprint: job.inputFingerprint,
+            approvalScopeKey: job.approvalScopeKey,
+            priority: job.priority,
+            safeLabel: job.safeLabel,
+            state: recoveryState,
+            persistedAt: _now(),
+        };
+    }
+
+    function _persistRecoverableRefs() {
+        const refs = [];
+        for (const job of jobs.values()) {
+            const ref = _recoverableRef(job);
+            if (ref) refs.push(ref);
+        }
+        if (refs.length) _writeJsonStorage(RECOVERY_STORAGE_KEY, refs);
+        else _storageRemove(RECOVERY_STORAGE_KEY);
+    }
+
+    function _loadRecoverableRefs() {
+        const refs = _readJsonStorage(RECOVERY_STORAGE_KEY, []);
+        for (const ref of Array.isArray(refs) ? refs : []) {
+            const jobId = _safeId(ref && ref.jobId, '');
+            if (!jobId) continue;
+            pendingRecoverableRefs.set(jobId, _safeValue(ref));
+        }
+    }
+
+    function _jobFromRecoveryRef(ref, state) {
+        const now = _now();
+        const job = {
+            jobId: _safeId(ref.jobId, _id('job')),
+            logicalJobKey: _safeId(ref.logicalJobKey || '', ''),
+            jobType: _safeId(ref.jobType, 'unknown'),
+            providerId: _safeId(ref.providerId, 'unknown'),
+            requesterId: _safeId(ref.requesterId, 'unknown'),
+            targetRef: _safeId(ref.targetRef, 'target-unknown'),
+            inputFingerprint: _safeId(ref.inputFingerprint, 'input-unknown'),
+            approvalScope: null,
+            approvalScopeKey: _safeId(ref.approvalScopeKey, ''),
+            authorization: 'recovered',
+            priority: _priority(ref.priority),
+            safeLabel: _safeText(ref.safeLabel || 'Recovered job', 'Recovered job', MAX_LABEL),
+            state,
+            progress: { mode: 'indeterminate', percent: null, step: 'recovered', message: 'Recovered after reload', updatedAt: now },
+            attempts: [],
+            history: [],
+            retryable: false,
+            safeReason: state === STATES.PROVIDER_UNAVAILABLE || state === STATES.ORPHANED ? 'Provider recovery unavailable after reload' : 'Recovered after reload',
+            terminalOutcome: null,
+            bridgeSource: null,
+            createdAt: ref.createdAt || now,
+            queuedAt: state === STATES.QUEUED ? now : null,
+            startedAt: state === STATES.RUNNING ? now : null,
+            updatedAt: now,
+            terminalAt: null,
+        };
+        job.attempts.push(_newAttempt(job, state));
+        return job;
+    }
+
+    function _recoverRefsForProvider(provider) {
+        for (const [jobId, ref] of Array.from(pendingRecoverableRefs.entries())) {
+            if (ref.providerId !== provider.providerId || jobs.has(jobId)) continue;
+            const recoverState = ref.state === STATES.PAUSED ? STATES.PAUSED : (ref.state === STATES.RUNNING ? STATES.RUNNING : STATES.QUEUED);
+            if (!provider.recoverySupport[recoverState]) {
+                const job = _jobFromRecoveryRef(ref, STATES.PROVIDER_UNAVAILABLE);
+                _terminal(job, 'provider-unavailable', 'provider-unavailable', 'Provider does not support recovery for this job state', false);
+                jobs.set(job.jobId, job);
+                pendingRecoverableRefs.delete(jobId);
+                continue;
+            }
+            let nextState = recoverState;
+            const recoveryResult = _callProvider(provider, 'job.recover', { ref });
+            if (recoveryResult && recoveryResult.state && [STATES.QUEUED, STATES.RUNNING, STATES.PAUSED].includes(recoveryResult.state)) nextState = recoveryResult.state;
+            const job = _jobFromRecoveryRef(ref, nextState);
+            jobs.set(job.jobId, job);
+            _history(job, 'event', 'Recovered job reference after reload');
+            _emitJobs(nextState === STATES.PAUSED ? 'paused' : (nextState === STATES.RUNNING ? 'started' : 'queued'), { job: _jobSummary(job, { includeHistory: false }) });
+            pendingRecoverableRefs.delete(jobId);
+        }
+        _persistRecoverableRefs();
+    }
+
+    function _registerProviderCommand(ctx) {
+        const provider = _normalizeProvider(ctx.payload && ctx.payload.provider || ctx.payload);
+        if (!provider.providerId || !provider.jobTypes.length) {
+            _rememberOutcome('register-provider', 'validation-failed', { safeReason: 'providerId and jobTypes are required' });
+            return _result('validation-failed', {}, 'providerId and jobTypes are required');
+        }
+        if (provider.version !== 1 || provider.availability === 'incompatible') provider.availability = 'incompatible';
+        const existing = providers.get(provider.providerId);
+        providers.set(provider.providerId, { ...(existing || {}), ...provider, lastSeenAt: _now() });
+        _recoverRefsForProvider(provider);
+        _rememberOutcome('register-provider', provider.availability === 'incompatible' ? 'incompatible-version' : 'handled', { providerId: provider.providerId, safeReason: provider.safeReason });
+        _emitJobs('provider-registered', { provider: _providerSummary(provider) });
+        return provider.availability === 'incompatible'
+            ? _result('incompatible-version', { provider: _providerSummary(provider) }, provider.safeReason || 'Provider version incompatible')
+            : _handled({ provider: _providerSummary(provider) });
+    }
+
+    function _unregisterProviderCommand(ctx) {
+        const providerId = _safeId(ctx.payload && (ctx.payload.providerId || ctx.payload.id), '');
+        if (!providerId || !providers.has(providerId)) return _result('no-target', {}, 'provider not found');
+        providers.delete(providerId);
+        for (const job of jobs.values()) {
+            if (job.providerId !== providerId || TERMINAL_STATES.has(job.state)) continue;
+            _terminal(job, 'provider-unavailable', 'provider-unavailable', 'Provider unregistered', true);
+        }
+        _rememberOutcome('unregister-provider', 'handled', { providerId });
+        return _handled({ providerId });
+    }
+
+    function _listProvidersCommand() {
+        return _handled({ providers: Array.from(providers.values()).map(_providerSummary), selectedProviders: Array.from(selectedProviders.values()).map(item => _safeValue(item)) });
+    }
+
+    function _enqueueCommand(ctx) {
+        const args = _plainObject(ctx.payload);
+        if (!_safeId(args.jobType, '')) return _result('validation-failed', {}, 'jobType is required');
+        if (!args.requester && !args.requesterId && !ctx.requester) return _result('validation-failed', {}, 'requester is required');
+        if (!args.requester && ctx.requester) args.requester = ctx.requester;
+        const resolved = _resolveProvider(args);
+        if (!resolved.provider) {
+            _rememberOutcome('enqueue', resolved.outcome, { requesterId: _safeId(args.requester || ctx.requester, 'unknown'), safeReason: resolved.reason });
+            return _result(resolved.outcome, {}, resolved.reason);
+        }
+        const provider = resolved.provider;
+        if (!_authorizationAllowed(args, provider.providerId)) {
+            const outcome = args.authorization === 'background' || args.authorization === 'none' || !args.authorization ? 'user-action-required' : 'denied';
+            _rememberOutcome('enqueue', outcome, { providerId: provider.providerId, requesterId: _safeId(args.requester || ctx.requester, 'unknown'), safeReason: 'Explicit user action required before privileged work starts' });
+            return _result(outcome, {}, 'Explicit user action required before privileged work starts');
+        }
+        const duplicate = _findDuplicateJob(args, provider.providerId);
+        if (duplicate) {
+            _rememberOutcome('enqueue', 'handled', { jobId: duplicate.jobId, providerId: provider.providerId, requesterId: duplicate.requesterId, safeReason: 'Duplicate logical job suppressed' });
+            return _handled({ job: _jobSummary(duplicate, { includeHistory: false }), duplicate: true });
+        }
+        const job = _newJob(args, provider.providerId);
+        jobs.set(job.jobId, job);
+        _history(job, 'event', 'Job queued');
+        _rememberOutcome('enqueue', 'queued', { jobId: job.jobId, providerId: provider.providerId, requesterId: job.requesterId });
+        _emitJobs('queued', { job: _jobSummary(job, { includeHistory: false }) });
+        _scheduleProvider(provider.providerId);
+        return _result(job.state === STATES.RUNNING ? 'handled' : 'queued', { job: _jobSummary(job) });
+    }
+
+    function _listCommand(ctx) {
+        const filters = _plainObject(ctx.payload);
+        const includeTerminal = filters.includeTerminal !== false;
+        const summaries = Array.from(jobs.values()).filter(job => {
+            if (filters.providerId && job.providerId !== filters.providerId) return false;
+            if (filters.jobType && job.jobType !== filters.jobType) return false;
+            if (filters.state && job.state !== filters.state) return false;
+            if (filters.requesterId && job.requesterId !== filters.requesterId) return false;
+            if (!includeTerminal && TERMINAL_STATES.has(job.state)) return false;
+            return true;
+        }).map(job => _jobSummary(job, { includeHistory: false }));
+        return _handled({ jobs: summaries, providers: Array.from(providers.values()).map(_providerSummary) });
+    }
+
+    function _inspectCommand(ctx) {
+        const jobId = _safeId(ctx.payload && ctx.payload.jobId, '');
+        if (!jobId || !jobs.has(jobId)) return _result('no-target', {}, 'job not found');
+        const job = jobs.get(jobId);
+        return _handled({ job: _jobSummary(job), provider: providers.has(job.providerId) ? _providerSummary(providers.get(job.providerId)) : null });
+    }
+
+    function _unsupportedIfNoAction(job, action) {
+        const provider = providers.get(job.providerId);
+        if (!provider || !_providerCanRun(provider)) return { outcome: 'unavailable', reason: 'Provider unavailable' };
+        if (!provider.actions.includes(action) && !(action === 'cancel' && job.state === STATES.QUEUED)) return { outcome: 'unsupported-operation', reason: `${action} is unsupported` };
+        return { provider };
+    }
+
+    function _cancelCommand(ctx) {
+        const jobId = _safeId(ctx.payload && ctx.payload.jobId, '');
+        const job = jobs.get(jobId);
+        if (!job) return _result('no-target', {}, 'job not found');
+        if (TERMINAL_STATES.has(job.state)) return _result('stale', { job: _jobSummary(job) }, 'job is already terminal');
+        if (job.state === STATES.QUEUED) {
+            _terminal(job, 'cancelled', 'cancellation', 'Cancelled before start', false);
+            _rememberOutcome('cancel', 'cancelled', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId });
+            _emitJobs('cancelled', { job: _jobSummary(job, { includeHistory: false }) });
+            _scheduleProvider(job.providerId);
+            return _result('cancelled', { job: _jobSummary(job) });
+        }
+        const check = _unsupportedIfNoAction(job, 'cancel');
+        if (!check.provider) return _result(check.outcome, { job: _jobSummary(job) }, check.reason);
+        job.state = STATES.CANCELLATION_REQUESTED;
+        job.updatedAt = _now();
+        _history(job, 'event', 'Cancellation requested');
+        _callProvider(check.provider, 'job.cancel', { job: _jobSummary(job, { includeHistory: false }), requester: ctx.payload && ctx.payload.requester });
+        _rememberOutcome('cancel', 'handled', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId, safeReason: 'Cancellation requested' });
+        _emitJobs('cancellation-requested', { job: _jobSummary(job, { includeHistory: false }) });
+        return _handled({ job: _jobSummary(job) });
+    }
+
+    function _pauseCommand(ctx) {
+        const jobId = _safeId(ctx.payload && ctx.payload.jobId, '');
+        const job = jobs.get(jobId);
+        if (!job) return _result('no-target', {}, 'job not found');
+        if (TERMINAL_STATES.has(job.state) || job.state !== STATES.RUNNING) return _result('stale', { job: _jobSummary(job) }, 'job is not running');
+        const check = _unsupportedIfNoAction(job, 'pause');
+        if (!check.provider) return _result(check.outcome, { job: _jobSummary(job) }, check.reason);
+        job.state = STATES.PAUSED;
+        job.updatedAt = _now();
+        _history(job, 'event', 'Job paused');
+        _callProvider(check.provider, 'job.pause', { job: _jobSummary(job, { includeHistory: false }) });
+        _rememberOutcome('pause', 'handled', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId });
+        _emitJobs('paused', { job: _jobSummary(job, { includeHistory: false }) });
+        return _handled({ job: _jobSummary(job) });
+    }
+
+    function _resumeCommand(ctx) {
+        const jobId = _safeId(ctx.payload && ctx.payload.jobId, '');
+        const job = jobs.get(jobId);
+        if (!job) return _result('no-target', {}, 'job not found');
+        if (TERMINAL_STATES.has(job.state) || job.state !== STATES.PAUSED) return _result('stale', { job: _jobSummary(job) }, 'job is not paused');
+        const check = _unsupportedIfNoAction(job, 'resume');
+        if (!check.provider) return _result(check.outcome, { job: _jobSummary(job) }, check.reason);
+        job.state = STATES.QUEUED;
+        job.queuedAt = _now();
+        job.updatedAt = _now();
+        _history(job, 'event', 'Job resumed');
+        _callProvider(check.provider, 'job.resume', { job: _jobSummary(job, { includeHistory: false }) });
+        _rememberOutcome('resume', 'queued', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId });
+        _emitJobs('resumed', { job: _jobSummary(job, { includeHistory: false }) });
+        _scheduleProvider(job.providerId);
+        return _result(job.state === STATES.RUNNING ? 'handled' : 'queued', { job: _jobSummary(job) });
+    }
+
+    function _retryCommand(ctx) {
+        const args = _plainObject(ctx.payload);
+        const jobId = _safeId(args.jobId, '');
+        const job = jobs.get(jobId);
+        if (!job) return _result('no-target', {}, 'job not found');
+        if (!TERMINAL_STATES.has(job.state)) return _result('stale', { job: _jobSummary(job) }, 'job is not terminal');
+        if (!job.retryable) return _result('unsupported-operation', { job: _jobSummary(job) }, 'job is not retryable');
+        if (job.attempts.some(attempt => !TERMINAL_STATES.has(attempt.state))) return _result('stale', { job: _jobSummary(job) }, 'retry already active');
+        if (args.authorization !== 'user-action') {
+            if (args.authorization !== 'approved-continuation' || _safeId(args.approvalScopeKey || args.approvalKey, '') !== job.approvalScopeKey) {
+                return _result(args.authorization ? 'denied' : 'user-action-required', { job: _jobSummary(job) }, 'matching approval required for retry');
+            }
+        }
+        const provider = providers.get(job.providerId);
+        if (!provider || !_providerCanRun(provider)) return _result('unavailable', { job: _jobSummary(job) }, 'provider unavailable');
+        if (!provider.actions.includes('retry') && !provider.actions.includes('enqueue')) return _result('unsupported-operation', { job: _jobSummary(job) }, 'retry unsupported');
+        job.state = STATES.QUEUED;
+        job.terminalOutcome = null;
+        job.terminalAt = null;
+        job.retryable = false;
+        job.queuedAt = _now();
+        job.updatedAt = _now();
+        job.attempts.push(_newAttempt(job, STATES.QUEUED));
+        _history(job, 'event', 'Retry attempt queued');
+        _callProvider(provider, 'job.retry', { job: _jobSummary(job, { includeHistory: false }) });
+        _rememberOutcome('retry', 'retry-started', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId });
+        _emitJobs('retried', { job: _jobSummary(job, { includeHistory: false }) });
+        _scheduleProvider(job.providerId);
+        return _result('retry-started', { job: _jobSummary(job) });
+    }
+
+    function _recordBridgeHitCommand(ctx) {
+        const source = _plainObject(ctx.payload);
+        const bridge = {
+            bridgeId: _safeId(source.bridgeId || (BRIDGE_IDS.has(source.legacySurface) ? source.legacySurface : 'jobs.legacy-plugin-queue'), 'jobs.legacy-plugin-queue'),
+            legacySurface: _safeId(source.legacySurface || 'plugin-queue', 'plugin-queue'),
+            pluginId: _safeId(source.pluginId || source.source || 'unknown', 'unknown'),
+            operation: _safeText(source.operation || 'unknown', 'unknown', 80),
+            jobId: source.jobId && jobs.has(source.jobId) ? source.jobId : null,
+            providerId: source.providerId && providers.has(source.providerId) ? source.providerId : null,
+            logicalJobKey: _safeId(source.logicalJobKey || '', ''),
+            diagnosticsOnly: false,
+            timestamp: _now(),
+            safeReason: _safeText(source.safeReason || source.reason || 'legacy surface observed'),
+        };
+        if (!bridge.jobId && bridge.logicalJobKey) {
+            for (const job of jobs.values()) {
+                if (job.logicalJobKey === bridge.logicalJobKey) {
+                    bridge.jobId = job.jobId;
+                    bridge.providerId = job.providerId;
+                    bridge.diagnosticsOnly = true;
+                    break;
+                }
+            }
+        }
+        bridgeHits.push(bridge);
+        while (bridgeHits.length > MAX_BRIDGES) bridgeHits.shift();
+        if (capabilities && typeof capabilities.registerCompatibilityShim === 'function') {
+            capabilities.registerCompatibilityShim({
+                shimId: bridge.bridgeId,
+                source: bridge.pluginId,
+                capability: 'jobs',
+                legacySurface: bridge.legacySurface,
+                status: 'used',
+                reason: bridge.safeReason,
+                hit: true,
+                providerId: bridge.providerId,
+                ownerPluginId: bridge.pluginId,
+            });
+        }
+        _rememberOutcome('record-bridge-hit', 'handled', { jobId: bridge.jobId, providerId: bridge.providerId, safeReason: bridge.safeReason });
+        _emitJobs('bridge-hit', { bridge });
+        return _handled({ bridge });
+    }
+
+    function _scheduleProvider(providerId) {
+        const provider = providers.get(providerId);
+        if (!provider || !_providerCanRun(provider)) return;
+        let load = _providerLoad(providerId);
+        const queued = Array.from(jobs.values())
+            .filter(job => job.providerId === providerId && job.state === STATES.QUEUED)
+            .sort((a, b) => _priorityRank(a) - _priorityRank(b) || String(a.queuedAt || '').localeCompare(String(b.queuedAt || '')) || a.jobId.localeCompare(b.jobId));
+        for (const job of queued) {
+            if (load.running >= provider.capacity.maxRunning) {
+                job.safeReason = 'Waiting for provider capacity';
+                continue;
+            }
+            _startJob(job, provider);
+            load = _providerLoad(providerId);
+        }
+        _persistRecoverableRefs();
+    }
+
+    function _startJob(job, provider) {
+        if (!job || !provider || job.state !== STATES.QUEUED) return;
+        job.state = STATES.RUNNING;
+        job.startedAt = job.startedAt || _now();
+        job.updatedAt = _now();
+        job.safeReason = null;
+        const attempt = job.attempts[job.attempts.length - 1];
+        if (attempt) {
+            attempt.state = STATES.RUNNING;
+            attempt.startedAt = attempt.startedAt || _now();
+            attempt.updatedAt = _now();
+        }
+        _history(job, 'event', 'Job started');
+        const result = _callProvider(provider, 'job.enqueue', { job: _jobSummary(job, { includeHistory: false }) });
+        if (result && result.progress) updateProgress(provider.providerId, job.jobId, result.progress);
+        _emitJobs('started', { job: _jobSummary(job, { includeHistory: false }) });
+    }
+
+    function _terminal(job, outcomeStatus, category, safeReason, retryable, resultSummary = '') {
+        const status = outcomeStatus === 'timeout' ? 'failed' : outcomeStatus;
+        job.state = status === 'provider-unavailable' ? STATES.PROVIDER_UNAVAILABLE : (status === 'orphaned' ? STATES.ORPHANED : (status === 'cancelled' ? STATES.CANCELLED : (status === 'completed' ? STATES.COMPLETED : STATES.FAILED)));
+        job.retryable = !!retryable;
+        job.safeReason = safeReason ? _safeText(safeReason) : null;
+        job.terminalAt = _now();
+        job.updatedAt = job.terminalAt;
+        job.terminalOutcome = {
+            status: outcomeStatus,
+            category: FAILURE_CATEGORIES.has(category) ? category : (outcomeStatus === 'completed' ? null : 'unknown'),
+            retryable: !!retryable,
+            safeReason: job.safeReason,
+            resultSummary: resultSummary ? _safeText(resultSummary) : null,
+        };
+        const attempt = job.attempts[job.attempts.length - 1];
+        if (attempt) {
+            attempt.state = job.state;
+            attempt.updatedAt = job.updatedAt;
+            attempt.terminalAt = job.terminalAt;
+            attempt.terminalOutcome = _clone(job.terminalOutcome);
+        }
+        if (!terminalJobIds.includes(job.jobId)) terminalJobIds.push(job.jobId);
+        while (terminalJobIds.length > MAX_TERMINAL_JOBS) terminalJobIds.shift();
+        _history(job, 'event', `Job ${outcomeStatus}`);
+        _persistRecoverableRefs();
+        return job;
+    }
+
+    function updateProgress(providerId, jobId, progress = {}) {
+        const job = jobs.get(_safeId(jobId, ''));
+        if (!job || job.providerId !== providerId) return _result('no-target', {}, 'job not found');
+        if (TERMINAL_STATES.has(job.state)) {
+            _rememberOutcome('progress', 'stale', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId, safeReason: 'progress after terminal state' });
+            return _result('stale', { job: _jobSummary(job) }, 'job is terminal');
+        }
+        const source = _plainObject(progress);
+        const mode = source.mode === 'determinate' || source.mode === 'indeterminate' || source.mode === 'step-only' ? source.mode : (source.percent == null ? 'indeterminate' : 'determinate');
+        let percent = mode === 'determinate' ? Math.max(0, Math.min(100, _number(source.percent, 0) || 0)) : null;
+        let message = _safeText(source.message || source.safeMessage || '', '', MAX_REASON);
+        if (job.progress && job.progress.mode === 'determinate' && percent != null && job.progress.percent != null && percent < job.progress.percent && !source.newStep && !source.newAttempt) {
+            message = message || 'Progress decreased and was flagged';
+        }
+        job.progress = {
+            mode,
+            percent,
+            step: _safeText(source.step || source.currentStep || '', '', 80),
+            message,
+            updatedAt: _now(),
+        };
+        job.updatedAt = job.progress.updatedAt;
+        _history(job, 'progress', job.progress.message || job.progress.step || mode, { progress: job.progress });
+        _rememberOutcome('progress', 'handled', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId });
+        _emitJobs('progress', { job: _jobSummary(job, { includeHistory: false }) });
+        return _handled({ job: _jobSummary(job) });
+    }
+
+    function log(providerId, jobId, entry = {}) {
+        const job = jobs.get(_safeId(jobId, ''));
+        if (!job || job.providerId !== providerId) return _result('no-target', {}, 'job not found');
+        const message = typeof entry === 'string' ? entry : (entry.message || entry.safeMessage || '');
+        _history(job, 'log', message);
+        _emitJobs('log', { job: _jobSummary(job, { includeHistory: false }), message: _safeText(message) });
+        return _handled({ job: _jobSummary(job) });
+    }
+
+    function complete(providerId, jobId, result = {}) {
+        const job = jobs.get(_safeId(jobId, ''));
+        if (!job || job.providerId !== providerId) return _result('no-target', {}, 'job not found');
+        if (TERMINAL_STATES.has(job.state)) return _result('stale', { job: _jobSummary(job) }, 'job is terminal');
+        _terminal(job, 'completed', null, result.safeReason || result.reason || '', false, result.resultSummary || result.summary || 'Completed');
+        _rememberOutcome('complete', 'completed', { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId });
+        _emitJobs('completed', { job: _jobSummary(job, { includeHistory: false }) });
+        _scheduleProvider(providerId);
+        return _result('completed', { job: _jobSummary(job) });
+    }
+
+    function fail(providerId, jobId, result = {}) {
+        const job = jobs.get(_safeId(jobId, ''));
+        if (!job || job.providerId !== providerId) return _result('no-target', {}, 'job not found');
+        if (TERMINAL_STATES.has(job.state)) return _result('stale', { job: _jobSummary(job) }, 'job is terminal');
+        const status = result.status === 'timeout' ? 'timeout' : 'failed';
+        const category = FAILURE_CATEGORIES.has(result.category) ? result.category : (status === 'timeout' ? 'timeout' : 'provider-failure');
+        _terminal(job, status, category, result.safeReason || result.reason || 'Provider reported failure', !!result.retryable, result.resultSummary || 'Failed');
+        _rememberOutcome('fail', status, { jobId: job.jobId, providerId: job.providerId, requesterId: job.requesterId, category, safeReason: job.safeReason });
+        _emitJobs('failed', { job: _jobSummary(job, { includeHistory: false }) });
+        _scheduleProvider(providerId);
+        return _result(status, { job: _jobSummary(job) });
+    }
+
+    function markProviderUnavailable(providerId, reason = 'Provider unavailable') {
+        const provider = providers.get(providerId);
+        if (provider) {
+            provider.availability = 'unavailable';
+            provider.safeReason = _safeText(reason);
+            provider.lastSeenAt = _now();
+        }
+        for (const job of jobs.values()) {
+            if (job.providerId !== providerId || TERMINAL_STATES.has(job.state)) continue;
+            _terminal(job, 'provider-unavailable', 'provider-unavailable', reason, true);
+            _emitJobs('provider-unavailable', { job: _jobSummary(job, { includeHistory: false }) });
+        }
+        _contributeDiagnostics();
+    }
+
+    function simulateReload() {
+        for (const job of Array.from(jobs.values())) {
+            if (!ACTIVE_STATES.has(job.state)) continue;
+            const provider = providers.get(job.providerId);
+            const recoveryState = job.state === STATES.CANCELLATION_REQUESTED ? STATES.RUNNING : job.state;
+            if (provider && provider.recoverySupport[recoveryState]) continue;
+            _terminal(job, provider ? 'orphaned' : 'provider-unavailable', provider ? 'unknown' : 'provider-unavailable', provider ? 'Job has no provider-declared recovery support' : 'Provider unavailable during reload', false);
+            _emitJobs(provider ? 'orphaned' : 'provider-unavailable', { job: _jobSummary(job, { includeHistory: false }) });
+        }
+        _persistRecoverableRefs();
+        _contributeDiagnostics();
+    }
+
+    function setSelectedProvider(jobType, providerId, source = 'user-selected') {
+        const normalizedJobType = _safeId(jobType, '');
+        const normalizedProviderId = _safeId(providerId, '');
+        if (!normalizedJobType || !normalizedProviderId) return { ok: false, reason: 'jobType and providerId are required' };
+        selectedProviders.set(normalizedJobType, { jobType: normalizedJobType, providerId: normalizedProviderId, source: _safeId(source, 'user-selected'), updatedAt: _now() });
+        _persistSelectedProviders();
+        _contributeDiagnostics();
+        return { ok: true };
+    }
+
+    function _snapshotJobs() {
+        const active = [];
+        const queued = [];
+        const paused = [];
+        const recentTerminal = [];
+        for (const job of jobs.values()) {
+            if (job.state === STATES.QUEUED) queued.push(_jobSummary(job));
+            else if (job.state === STATES.PAUSED) paused.push(_jobSummary(job));
+            else if (job.state === STATES.RUNNING || job.state === STATES.CANCELLATION_REQUESTED) active.push(_jobSummary(job));
+        }
+        for (const jobId of terminalJobIds.slice(-MAX_TERMINAL_JOBS)) {
+            const job = jobs.get(jobId);
+            if (job && TERMINAL_STATES.has(job.state)) recentTerminal.push(_jobSummary(job));
+        }
+        return { active, queued, paused, recentTerminal };
+    }
+
+    function snapshot(options = {}) {
+        const jobsSnapshot = _snapshotJobs();
+        const notes = [];
+        if (pendingRecoverableRefs.size) notes.push(`${pendingRecoverableRefs.size} recoverable job reference(s) awaiting provider registration`);
+        const result = {
+            schema: SCHEMA,
+            generatedAt: _now(),
+            providers: Array.from(providers.values()).map(_providerSummary),
+            selectedProviders: Array.from(selectedProviders.values()).map(item => _safeValue(item)),
+            jobs: jobsSnapshot,
+            outcomes: outcomes.slice(-MAX_OUTCOMES).map(item => _safeValue(item)),
+            bridgeHits: bridgeHits.slice(-MAX_BRIDGES).map(item => _safeValue(item)),
+            limits: {
+                terminalJobsRetained: MIN_TERMINAL_RETAINED,
+                perJobHistoryLimit: MAX_HISTORY_PER_JOB,
+                snapshotBudgetBytes: SNAPSHOT_BUDGET_BYTES,
+            },
+            notes,
+        };
+        let currentSize = JSON.stringify(result).length;
+        while (result.jobs.recentTerminal.length > MIN_TERMINAL_RETAINED && currentSize > SNAPSHOT_BUDGET_BYTES) {
+            const removed = result.jobs.recentTerminal.shift();
+            currentSize -= JSON.stringify(removed).length;
+        }
+        for (const group of ['active', 'queued', 'paused', 'recentTerminal']) {
+            for (const job of result.jobs[group]) {
+                while (job.history && job.history.length && JSON.stringify(result).length > SNAPSHOT_BUDGET_BYTES) job.history.shift();
+            }
+        }
+        result.snapshotBytes = JSON.stringify(result).length;
+        return _safeValue(result);
+    }
+
+    let contributing = false;
+    function _contributeDiagnostics() {
+        if (contributing) return;
+        const diagnostics = window.slopsmith && window.slopsmith.diagnostics;
+        if (diagnostics && typeof diagnostics.contribute === 'function') {
+            contributing = true;
+            try { diagnostics.contribute('jobs', snapshot()); }
+            catch (_) {}
+            finally { contributing = false; }
+        }
+        try { window.dispatchEvent(new CustomEvent('slopsmith:capabilities:changed', { detail: { timestamp: _now() } })); }
+        catch (_) {}
+    }
+
+    function resetForTests(options = {}) {
+        providers.clear();
+        selectedProviders.clear();
+        jobs.clear();
+        terminalJobIds.length = 0;
+        outcomes.length = 0;
+        bridgeHits.length = 0;
+        pendingRecoverableRefs.clear();
+        if (options.clearStorage !== false) {
+            _storageRemove(SELECTED_PROVIDER_STORAGE_KEY);
+            _storageRemove(RECOVERY_STORAGE_KEY);
+        }
+        _loadSelectedProviders();
+        _loadRecoverableRefs();
+        _contributeDiagnostics();
+    }
+
+    _loadSelectedProviders();
+    _loadRecoverableRefs();
+
+    capabilities.registerOwner('jobs', {
+        pluginId: OWNER_ID,
+        kind: 'provider-coordinator',
+        compatibility: 'shim-allowed',
+        ownership: 'multi-provider',
+        safety: 'privileged',
+        commands: ['register-provider', 'unregister-provider', 'list-providers', 'enqueue', 'list', 'inspect', 'cancel', 'pause', 'resume', 'retry', 'record-bridge-hit'],
+        operations: ['job.enqueue', 'job.status', 'job.cancel', 'job.pause', 'job.resume', 'job.retry', 'job.recover'],
+        events: ['provider-registered', 'provider-unregistered', 'provider-unavailable', 'queued', 'started', 'progress', 'log', 'paused', 'resumed', 'cancellation-requested', 'cancelled', 'completed', 'failed', 'retried', 'orphaned', 'bridge-hit'],
+        description: 'Owns the privileged jobs provider registry, scheduling, lifecycle state, recovery, bridge hits, and redaction-safe diagnostics.',
+        provider_policy: { providerId: 'jobs', kind: 'core', safety: 'privileged' },
+        handlers: {
+            'register-provider': _registerProviderCommand,
+            'unregister-provider': _unregisterProviderCommand,
+            'list-providers': _listProvidersCommand,
+            enqueue: _enqueueCommand,
+            list: _listCommand,
+            inspect: _inspectCommand,
+            cancel: _cancelCommand,
+            pause: _pauseCommand,
+            resume: _resumeCommand,
+            retry: _retryCommand,
+            'record-bridge-hit': _recordBridgeHitCommand,
+        },
+    });
+
+    const api = {
+        version: 1,
+        constants: { schema: SCHEMA, states: STATES, outcomes: Array.from(OUTCOMES), limits: { perJobHistoryLimit: MAX_HISTORY_PER_JOB, snapshotBudgetBytes: SNAPSHOT_BUDGET_BYTES } },
+        snapshot,
+        getDiagnostics: snapshot,
+        registerProvider(provider) { return _registerProviderCommand({ payload: { provider }, requester: 'api' }); },
+        unregisterProvider(providerId) { return _unregisterProviderCommand({ payload: { providerId }, requester: 'api' }); },
+        setSelectedProvider,
+        updateProgress,
+        reportProgress: updateProgress,
+        log,
+        complete,
+        fail,
+        markProviderUnavailable,
+        simulateReload,
+        resetForTests,
+        _test: { reset: resetForTests, providers, jobs, selectedProviders, pendingRecoverableRefs, storage: memoryStorage },
+    };
+
+    window.slopsmith.jobs = api;
+    _contributeDiagnostics();
+})();
\ No newline at end of file
diff --git a/static/index.html b/static/index.html
index 01ae44c..dd69109 100644
--- a/static/index.html
+++ b/static/index.html
@@ -24,6 +24,7 @@
     <script src="/static/capabilities.js"></script>
     <script src="/static/capabilities/library.js"></script>
     <script src="/static/capabilities/tuning.js"></script>
+    <script src="/static/capabilities/jobs.js"></script>
     <script src="/static/capabilities/audio-session.js"></script>
     <script src="/static/capabilities/audio-effects.js"></script>
     <script src="/static/capabilities/playback.js"></script>
diff --git a/tests/js/capabilities_diagnostics.test.js b/tests/js/capabilities_diagnostics.test.js
index b321b82..ad49685 100644
--- a/tests/js/capabilities_diagnostics.test.js
+++ b/tests/js/capabilities_diagnostics.test.js
@@ -50,7 +50,7 @@ test('diagnostics export expected compatibility shim surfaces', () => {
     assert.equal(expected.some(entry => entry.capability === 'jobs'), false);
 });
 
-test('diagnostics include active playback but exclude deferred and documentation-only future core domains', () => {
+test('diagnostics include active playback and jobs but exclude deferred future core domains', () => {
     const window = loadCapabilities();
     const api = window.slopsmith.capabilities;
     api.registerParticipant('playback_probe', {
@@ -74,14 +74,14 @@ test('diagnostics include active playback but exclude deferred and documentation
     const playback = pipelines.find(entry => entry.name === 'playback');
     assert.ok(playback, 'playback should be part of the active runtime graph when participants register');
     assert.equal(playback.review.lifecycle, 'active');
+    const jobs = pipelines.find(entry => entry.name === 'jobs');
+    assert.ok(jobs, 'jobs should be part of the active runtime graph when participants register');
+    assert.equal(jobs.review.lifecycle, 'active');
 
     // `visualization` (cap:6 slice) and `note-detection` (spec 009 slice)
     // left this list when their domains were promoted.
     const futureDomains = [
-        'ui.navigation', 'ui.plugin-screens', 'settings',
-        'backend.routes', 'ui.player-controls',
-        'ui.player-panels', 'ui.player-overlays', 'plugins', 'jobs', 'midi-control',
-        'tempo-clock',
+        'ui.navigation', 'ui.plugin-screens', 'settings', 'backend.routes', 'ui.player-controls', 'ui.player-panels', 'ui.player-overlays', 'plugins', 'midi-control', 'tempo-clock',
     ];
 
     for (const domain of futureDomains) {
diff --git a/tests/js/capability_inspector_render.test.js b/tests/js/capability_inspector_render.test.js
index 0396901..9eb747b 100644
--- a/tests/js/capability_inspector_render.test.js
+++ b/tests/js/capability_inspector_render.test.js
@@ -65,6 +65,9 @@ function loadInspector(snapshot, options = {}) {
             playback: options.playbackSnapshot ? {
                 snapshot: () => options.playbackSnapshot,
             } : undefined,
+            jobs: options.jobsSnapshot ? {
+                snapshot: () => options.jobsSnapshot,
+            } : undefined,
         },
         navigator: { clipboard: { writeText: async () => {} } },
         document: {
@@ -114,6 +117,41 @@ test('capability inspector renders playback session route loop bridges and outco
     assert.match(content, /seek:completed/);
 });
 
+test('capability inspector renders jobs support state and active domain graph', () => {
+    const snapshot = {
+        pipelines: [{ name: 'jobs', review: { lifecycle: 'active', label: 'Active contract', tone: 'clean', summary: 'Jobs control plane.' }, participants: [{ pluginId: 'core.jobs', kind: 'provider-coordinator', roles: ['owner'], commands: ['enqueue', 'list', 'inspect'], operations: ['job.enqueue'], events: ['queued', 'completed'], runtime: true, availability: 'available', ownership: 'multi-provider', safety: 'privileged' }], conflicts: [] }],
+        participants: [{ pluginId: 'core.jobs' }],
+        compatibilityShims: [],
+        expectedCompatibilityShims: [],
+    };
+    const jobsSnapshot = {
+        schema: 'slopsmith.jobs.diagnostics.v1',
+        providers: [{ providerId: 'provider.cache', label: 'Cache Builder', availability: 'available', jobTypes: ['cache-build'] }],
+        selectedProviders: [{ jobType: 'cache-build', providerId: 'provider.cache', source: 'user-selected' }],
+        jobs: {
+            active: [{ jobId: 'job-1', safeLabel: 'Build cache', providerId: 'provider.cache', state: 'running', progress: { percent: 42 } }],
+            queued: [{ jobId: 'job-2', safeLabel: 'Later cache', providerId: 'provider.cache', priority: 'background-maintenance' }],
+            paused: [],
+            recentTerminal: [{ jobId: 'job-0', safeLabel: 'Old cache', providerId: 'provider.cache', state: 'completed', terminalOutcome: { status: 'completed' } }],
+        },
+        outcomes: [{ operation: 'enqueue', status: 'queued' }, { operation: 'complete', status: 'completed' }],
+        bridgeHits: [{ bridgeId: 'jobs.legacy-plugin-queue', operation: 'enqueue', diagnosticsOnly: true }],
+    };
+    const { elements } = loadInspector(snapshot, { jobsSnapshot });
+    const content = elements.get('capability-inspector-content').innerHTML;
+    const filter = elements.get('capability-inspector-filter').innerHTML;
+
+    assert.match(content, /data-jobs-support/);
+    assert.match(content, /Providers: Cache Builder:available:cache-build/);
+    assert.match(content, /Selected: cache-build:provider.cache:user-selected/);
+    assert.match(content, /Active: Build cache:provider.cache:42%/);
+    assert.match(content, /Queued: Later cache:provider.cache:background-maintenance/);
+    assert.match(content, /Bridges: jobs.legacy-plugin-queue:enqueue:diagnostics-only/);
+    assert.match(content, /Outcomes: enqueue:queued, complete:completed/);
+    assert.match(content, /data-domain-graph="jobs"/);
+    assert.match(filter, /jobs/);
+});
+
 test('capability inspector renders shims inside their capability domain', () => {
     const snapshot = {
         pipelines: [
diff --git a/tests/js/jobs_compat.test.js b/tests/js/jobs_compat.test.js
new file mode 100644
index 0000000..1c28a0f
--- /dev/null
+++ b/tests/js/jobs_compat.test.js
@@ -0,0 +1,58 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { loadJobs, dispatch, makeProvider, enqueuePayload, diagnosticsSnapshot, captureEvents } = require('./jobs_test_harness');
+
+test('legacy bridge hits are recorded as diagnostics-only compatibility shims', async () => {
+    const window = loadJobs();
+    const events = captureEvents(window);
+    const { provider } = makeProvider({ providerId: 'provider.bridge' });
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload({ providerId: 'provider.bridge', logicalJobKey: 'legacy-key' }));
+
+    const result = await dispatch(window, 'record-bridge-hit', {
+        bridgeId: 'jobs.legacy-plugin-queue',
+        legacySurface: 'legacy-plugin-queue',
+        pluginId: 'legacy_plugin',
+        operation: 'enqueue',
+        logicalJobKey: 'legacy-key',
+        safeReason: 'legacy queue adapter used',
+    });
+    const runtimeSnapshot = window.slopsmith.capabilities.snapshotDiagnostics();
+    const diagnostics = diagnosticsSnapshot(window);
+
+    assert.equal(result.status, 'applied');
+    assert.equal(result.payload.bridge.jobId, enqueued.payload.job.jobId);
+    assert.equal(result.payload.bridge.diagnosticsOnly, true);
+    assert.ok(runtimeSnapshot.compatibilityShims.some(shim => shim.capability === 'jobs' && shim.status === 'used'));
+    assert.equal(diagnostics.bridgeHits.length, 1);
+    assert.ok(events.some(event => event.event === 'bridge-hit'));
+});
+
+test('duplicate logical jobs are suppressed and remain tied to the active job', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ providerId: 'provider.duplicate' });
+    await dispatch(window, 'register-provider', { provider });
+
+    const first = await dispatch(window, 'enqueue', enqueuePayload({ providerId: 'provider.duplicate', logicalJobKey: 'same-job' }));
+    const second = await dispatch(window, 'enqueue', enqueuePayload({ providerId: 'provider.duplicate', logicalJobKey: 'same-job' }));
+
+    assert.equal(second.status, 'applied');
+    assert.equal(second.payload.duplicate, true);
+    assert.equal(second.payload.job.jobId, first.payload.job.jobId);
+    assert.equal(diagnosticsSnapshot(window).jobs.active.length, 1);
+});
+
+test('unsupported provider actions return unsupported-operation instead of invoking callbacks', async () => {
+    const window = loadJobs();
+    const { calls, provider } = makeProvider({ providerId: 'provider.limited', actions: ['enqueue', 'inspect'] });
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload({ providerId: 'provider.limited' }));
+    calls.length = 0;
+
+    const pause = await dispatch(window, 'pause', { jobId: enqueued.payload.job.jobId });
+    const retry = await dispatch(window, 'retry', { jobId: enqueued.payload.job.jobId, authorization: 'user-action' });
+
+    assert.equal(pause.status, 'unsupported-operation');
+    assert.equal(retry.status, 'stale');
+    assert.equal(calls.length, 0);
+});
\ No newline at end of file
diff --git a/tests/js/jobs_diagnostics.test.js b/tests/js/jobs_diagnostics.test.js
new file mode 100644
index 0000000..15407c4
--- /dev/null
+++ b/tests/js/jobs_diagnostics.test.js
@@ -0,0 +1,73 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { loadJobs, dispatch, makeProvider, enqueuePayload, diagnosticsSnapshot, storageEntries } = require('./jobs_test_harness');
+
+test('diagnostics schema redacts raw payloads, paths, command lines, and provider-private fields', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider();
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload({
+        safeLabel: 'Generate cache',
+        target: { path: '/Users/example/Music/Secret Artist - Secret Song_p.psarc', filename: 'Secret Song_p.psarc' },
+        inputs: { token: 'abc123', rawPayload: 'never export', commandLine: 'ffmpeg -i secret.wav out.ogg', safeFingerprint: 'fingerprint-public' },
+    }));
+    window.slopsmith.jobs.log(provider.providerId, enqueued.payload.job.jobId, 'ran ffmpeg -i /Users/example/secret.wav with token=abc123');
+    window.slopsmith.jobs.fail(provider.providerId, enqueued.payload.job.jobId, { safeReason: 'failed near /Users/example/private/path', retryable: true });
+
+    const json = JSON.stringify(diagnosticsSnapshot(window));
+    assert.match(json, /Generate cache/);
+    assert.match(json, /fingerprint-public/);
+    assert.doesNotMatch(json, /Secret Artist|Secret Song|secret\.wav|abc123|rawPayload|commandLine|never export|ffmpeg -i/);
+});
+
+test('recoverable job references are the only active state persisted across reloads', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ providerId: 'provider.recover', recoverySupport: { queued: true, running: true, paused: false } });
+    await dispatch(window, 'register-provider', { provider });
+    await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: 'recoverable-running', safeLabel: 'Recoverable' }));
+
+    const entries = storageEntries(window);
+    assert.ok(entries['slopsmith.jobs.recoverableRefs.v1']);
+    assert.doesNotMatch(entries['slopsmith.jobs.recoverableRefs.v1'], /operationHandlers|rawPayload|token/);
+
+    const sameWindow = window;
+    sameWindow.slopsmith.jobs.resetForTests({ clearStorage: false });
+    assert.equal(sameWindow.slopsmith.jobs._test.pendingRecoverableRefs.size, 1);
+    await dispatch(sameWindow, 'register-provider', { provider });
+    const snapshot = diagnosticsSnapshot(sameWindow);
+    assert.equal(snapshot.jobs.active.length + snapshot.jobs.queued.length, 1);
+    assert.equal(snapshot.jobs.active[0]?.safeLabel || snapshot.jobs.queued[0]?.safeLabel, 'Recoverable');
+});
+
+test('reload marks non-recoverable jobs orphaned or provider-unavailable without restoring raw payloads', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ providerId: 'provider.no-recover', recoverySupport: { queued: false, running: false, paused: false } });
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload({ providerId: 'provider.no-recover', logicalJobKey: 'no-recover' }));
+
+    window.slopsmith.jobs.simulateReload();
+    const inspected = await dispatch(window, 'inspect', { jobId: enqueued.payload.job.jobId });
+
+    assert.equal(inspected.payload.job.state, 'orphaned');
+    assert.equal(inspected.payload.job.terminalOutcome.retryable, false);
+    assert.doesNotMatch(JSON.stringify(inspected.payload.job), /operationHandlers|rawPayload/);
+});
+
+test('diagnostics enforce per-job history and bounded snapshot size with terminal minimum retained', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ capacity: { maxRunning: 1, maxQueued: 100 } });
+    await dispatch(window, 'register-provider', { provider });
+    let lastJobId = null;
+
+    for (let index = 0; index < 8; index += 1) {
+        const enqueued = await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: `terminal-${index}`, safeLabel: `Terminal ${index}` }));
+        lastJobId = enqueued.payload.job.jobId;
+        for (let line = 0; line < 80; line += 1) window.slopsmith.jobs.log(provider.providerId, lastJobId, `line ${line} /Users/example/private/file-${line}.psarc`);
+        window.slopsmith.jobs.complete(provider.providerId, lastJobId, { resultSummary: 'done' });
+    }
+
+    const snapshot = diagnosticsSnapshot(window);
+    assert.ok(snapshot.snapshotBytes <= snapshot.limits.snapshotBudgetBytes + 1024);
+    assert.ok(snapshot.jobs.recentTerminal.length >= 5);
+    assert.ok(snapshot.jobs.recentTerminal.every(job => job.history.length <= 50));
+});
\ No newline at end of file
diff --git a/tests/js/jobs_domain.test.js b/tests/js/jobs_domain.test.js
new file mode 100644
index 0000000..8b961c0
--- /dev/null
+++ b/tests/js/jobs_domain.test.js
@@ -0,0 +1,78 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { loadJobs, dispatch, makeProvider, enqueuePayload, diagnosticsSnapshot, diagnosticsContributions } = require('./jobs_test_harness');
+
+test('jobs domain is active and registers the core provider coordinator owner', async () => {
+    const window = loadJobs();
+    const snapshot = window.slopsmith.capabilities.snapshotDiagnostics();
+    const jobs = snapshot.pipelines.find(pipeline => pipeline.name === 'jobs');
+
+    assert.ok(jobs);
+    assert.equal(jobs.review.lifecycle, 'active');
+    assert.equal(jobs.review.tone, 'clean');
+    assert.ok(jobs.participants.some(participant => participant.pluginId === 'core.jobs' && participant.kind === 'provider-coordinator' && participant.safety === 'privileged'));
+
+    const result = await dispatch(window, 'list-providers');
+    assert.equal(result.status, 'applied');
+    assert.equal(result.payload.providers.length, 0);
+});
+
+test('provider registration exposes safe metadata and rejects incompatible versions', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ providerId: 'provider.cache', label: 'Cache Builder', jobTypes: ['cache-build'] });
+
+    const registered = await dispatch(window, 'register-provider', { provider });
+    assert.equal(registered.status, 'applied');
+    assert.equal(registered.payload.provider.providerId, 'provider.cache');
+    assert.deepEqual(Array.from(registered.payload.provider.jobTypes), ['cache-build']);
+
+    const incompatible = await dispatch(window, 'register-provider', { provider: { ...provider, providerId: 'provider.old', version: 2, safeReason: 'requires runtime v2' } });
+    assert.equal(incompatible.status, 'incompatible-version');
+    assert.equal(incompatible.payload.provider.availability, 'incompatible');
+});
+
+test('privileged enqueue requires approval before provider work starts', async () => {
+    const window = loadJobs();
+    const { calls, provider } = makeProvider();
+    await dispatch(window, 'register-provider', { provider });
+
+    const result = await dispatch(window, 'enqueue', enqueuePayload({ authorization: 'background' }));
+
+    assert.equal(result.status, 'user-action-required');
+    assert.equal(calls.length, 0);
+    assert.equal(diagnosticsSnapshot(window).jobs.active.length, 0);
+    assert.equal(diagnosticsContributions(window).jobs.schema, 'slopsmith.jobs.diagnostics.v1');
+});
+
+test('approved enqueue queues and starts with redaction-safe public job fields', async () => {
+    const window = loadJobs();
+    const { calls, provider } = makeProvider({ capacity: { maxRunning: 1, maxQueued: 10 } });
+    await dispatch(window, 'register-provider', { provider });
+
+    const result = await dispatch(window, 'enqueue', enqueuePayload({ target: { path: '/Users/example/DLC/Secret.psarc' }, inputs: { token: 'secret', safeFingerprint: 'fingerprint-1' } }));
+    const job = result.payload.job;
+
+    assert.equal(result.status, 'applied');
+    assert.equal(job.state, 'running');
+    assert.equal(job.targetRef.startsWith('target-'), true);
+    assert.equal(job.inputFingerprint, 'fingerprint-1');
+    assert.equal(calls.length, 1);
+    assert.doesNotMatch(JSON.stringify(diagnosticsSnapshot(window)), /Secret\.psarc|token|secret/);
+});
+
+test('list and inspect are prompt-free and do not invoke provider callbacks', async () => {
+    const window = loadJobs();
+    const { calls, provider } = makeProvider();
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload());
+    calls.length = 0;
+
+    const listed = await dispatch(window, 'list');
+    const inspected = await dispatch(window, 'inspect', { jobId: enqueued.payload.job.jobId });
+
+    assert.equal(listed.status, 'applied');
+    assert.equal(inspected.status, 'applied');
+    assert.equal(listed.payload.jobs.length, 1);
+    assert.equal(inspected.payload.job.jobId, enqueued.payload.job.jobId);
+    assert.equal(calls.length, 0);
+});
\ No newline at end of file
diff --git a/tests/js/jobs_scheduling.test.js b/tests/js/jobs_scheduling.test.js
new file mode 100644
index 0000000..d39b2d5
--- /dev/null
+++ b/tests/js/jobs_scheduling.test.js
@@ -0,0 +1,71 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { loadJobs, dispatch, makeProvider, enqueuePayload, captureEvents, diagnosticsSnapshot } = require('./jobs_test_harness');
+
+test('multiple providers require explicit selection before scheduling', async () => {
+    const window = loadJobs();
+    await dispatch(window, 'register-provider', { provider: makeProvider({ providerId: 'provider.a' }).provider });
+    await dispatch(window, 'register-provider', { provider: makeProvider({ providerId: 'provider.b' }).provider });
+
+    const blocked = await dispatch(window, 'enqueue', enqueuePayload());
+    assert.equal(blocked.status, 'provider-selection-required');
+
+    window.slopsmith.jobs.setSelectedProvider('transcode', 'provider.b');
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: 'selected-job' }));
+    assert.equal(enqueued.status, 'applied');
+    assert.equal(enqueued.payload.job.providerId, 'provider.b');
+});
+
+test('provider capacity starts one job and keeps the rest queued in priority order', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ capacity: { maxRunning: 1, maxQueued: 10 } });
+    await dispatch(window, 'register-provider', { provider });
+
+    const first = await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: 'first', priority: 'background-maintenance' }));
+    const second = await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: 'second', priority: 'background-maintenance', safeLabel: 'Second' }));
+    const third = await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: 'third', priority: 'user-approved-interactive', safeLabel: 'Third' }));
+
+    assert.equal(first.payload.job.state, 'running');
+    assert.equal(second.payload.job.state, 'queued');
+    assert.equal(third.payload.job.state, 'queued');
+
+    window.slopsmith.jobs.complete(provider.providerId, first.payload.job.jobId, { resultSummary: 'done' });
+    const snapshot = diagnosticsSnapshot(window);
+    assert.equal(snapshot.jobs.active.length, 1);
+    assert.equal(snapshot.jobs.active[0].safeLabel, 'Third');
+});
+
+test('progress, completion, and terminal retention are reflected in events and diagnostics', async () => {
+    const window = loadJobs();
+    const events = captureEvents(window);
+    const { provider } = makeProvider();
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload());
+
+    window.slopsmith.jobs.updateProgress(provider.providerId, enqueued.payload.job.jobId, { percent: 33, step: 'convert', message: 'Converting safely' });
+    window.slopsmith.jobs.complete(provider.providerId, enqueued.payload.job.jobId, { resultSummary: 'Cache ready' });
+    const snapshot = diagnosticsSnapshot(window);
+
+    assert.equal(snapshot.jobs.active.length, 0);
+    assert.equal(snapshot.jobs.recentTerminal.length, 1);
+    assert.equal(snapshot.jobs.recentTerminal[0].terminalOutcome.status, 'completed');
+    assert.ok(snapshot.jobs.recentTerminal[0].history.some(entry => entry.kind === 'progress'));
+    assert.ok(events.some(event => event.event === 'progress'));
+    assert.ok(events.some(event => event.event === 'completed'));
+});
+
+test('cancel, pause, resume, retry, and stale transitions use canonical outcomes', async () => {
+    const window = loadJobs();
+    const { provider } = makeProvider({ capacity: { maxRunning: 1, maxQueued: 10 } });
+    await dispatch(window, 'register-provider', { provider });
+    const enqueued = await dispatch(window, 'enqueue', enqueuePayload({ logicalJobKey: 'control-job' }));
+    const jobId = enqueued.payload.job.jobId;
+
+    assert.equal((await dispatch(window, 'pause', { jobId })).status, 'applied');
+    assert.equal((await dispatch(window, 'resume', { jobId })).status, 'applied');
+    assert.equal((await dispatch(window, 'pause', { jobId })).status, 'applied');
+    assert.equal((await dispatch(window, 'cancel', { jobId })).status, 'applied');
+    window.slopsmith.jobs.fail(provider.providerId, jobId, { category: 'provider-failure', safeReason: 'retryable failure', retryable: true });
+    assert.equal((await dispatch(window, 'retry', { jobId, authorization: 'user-action' })).status, 'retry-started');
+    assert.equal((await dispatch(window, 'retry', { jobId, authorization: 'user-action' })).status, 'stale');
+});
\ No newline at end of file
diff --git a/tests/js/jobs_test_harness.js b/tests/js/jobs_test_harness.js
new file mode 100644
index 0000000..d05228e
--- /dev/null
+++ b/tests/js/jobs_test_harness.js
@@ -0,0 +1,159 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { createWindow, ROOT } = require('./capabilities_test_harness');
+
+const CAPABILITIES_JS = path.join(ROOT, 'static', 'capabilities.js');
+const JOBS_JS = path.join(ROOT, 'static', 'capabilities', 'jobs.js');
+const INSPECTOR_JS = path.join(ROOT, 'plugins', 'capability_inspector', 'screen.js');
+
+function loadJobs(options = {}) {
+    const window = createWindow(options);
+    const context = vm.createContext(window);
+    vm.runInContext(fs.readFileSync(CAPABILITIES_JS, 'utf8'), context, { filename: CAPABILITIES_JS });
+    vm.runInContext(fs.readFileSync(JOBS_JS, 'utf8'), context, { filename: JOBS_JS });
+    window.__vmContext = context;
+    return window;
+}
+
+function loadInspector(window) {
+    vm.runInContext(fs.readFileSync(INSPECTOR_JS, 'utf8'), window.__vmContext, { filename: INSPECTOR_JS });
+    return window;
+}
+
+function captureEvents(window, capability = 'jobs') {
+    const events = [];
+    window.slopsmith.on('capability:event', event => {
+        if (event.detail && event.detail.capability === capability) events.push(event.detail);
+    });
+    return events;
+}
+
+function diagnosticsSnapshot(window) {
+    return window.slopsmith.jobs.snapshot();
+}
+
+function diagnosticsContributions(window) {
+    return Object.fromEntries(window.__diagnosticsContributions || new Map());
+}
+
+function storageEntries(window) {
+    return Object.fromEntries(window.__storage || new Map());
+}
+
+async function dispatch(window, command, payload = {}, requester = 'test') {
+    return window.slopsmith.capabilities.dispatch({ capability: 'jobs', command, args: payload, requester });
+}
+
+function makeProvider(overrides = {}) {
+    const calls = [];
+    const providerId = overrides.providerId || 'provider.jobs';
+    const handlers = overrides.operationHandlers || {};
+    const provider = {
+        providerId,
+        pluginId: overrides.pluginId || providerId,
+        label: overrides.label || 'Jobs Provider',
+        jobTypes: overrides.jobTypes || ['transcode'],
+        actions: overrides.actions || ['enqueue', 'inspect', 'cancel', 'pause', 'resume', 'retry', 'recover'],
+        availability: overrides.availability || 'available',
+        capacity: overrides.capacity || { maxRunning: 1, maxQueued: 10 },
+        recoverySupport: overrides.recoverySupport || { queued: true, running: true, paused: true },
+        version: overrides.version || 1,
+        safeReason: overrides.safeReason,
+        operationHandlers: {
+            'job.enqueue': request => {
+                calls.push(['job.enqueue', request]);
+                return handlers['job.enqueue'] ? handlers['job.enqueue'](request) : { outcome: 'handled' };
+            },
+            'job.cancel': request => {
+                calls.push(['job.cancel', request]);
+                return handlers['job.cancel'] ? handlers['job.cancel'](request) : { outcome: 'handled' };
+            },
+            'job.pause': request => {
+                calls.push(['job.pause', request]);
+                return handlers['job.pause'] ? handlers['job.pause'](request) : { outcome: 'handled' };
+            },
+            'job.resume': request => {
+                calls.push(['job.resume', request]);
+                return handlers['job.resume'] ? handlers['job.resume'](request) : { outcome: 'handled' };
+            },
+            'job.retry': request => {
+                calls.push(['job.retry', request]);
+                return handlers['job.retry'] ? handlers['job.retry'](request) : { outcome: 'handled' };
+            },
+            'job.recover': request => {
+                calls.push(['job.recover', request]);
+                return handlers['job.recover'] ? handlers['job.recover'](request) : { outcome: 'handled', state: overrides.recoveredState || 'queued' };
+            },
+            ...handlers,
+        },
+    };
+    return { calls, provider };
+}
+
+function enqueuePayload(overrides = {}) {
+    return {
+        jobType: overrides.jobType || 'transcode',
+        requester: overrides.requester || 'plugin.requester',
+        authorization: overrides.authorization || 'user-action',
+        priority: overrides.priority || 'user-approved-interactive',
+        target: overrides.target || { targetRef: 'song-1' },
+        inputs: overrides.inputs || { safeFingerprint: 'input-1' },
+        safeLabel: overrides.safeLabel || 'Build playable cache',
+        logicalJobKey: overrides.logicalJobKey,
+        providerId: overrides.providerId,
+        privileged: overrides.privileged,
+        approvalScopeKey: overrides.approvalScopeKey,
+    };
+}
+
+function installInspectorDom(window) {
+    const elements = new Map();
+    function element(id) {
+        const item = {
+            id,
+            value: '',
+            textContent: '',
+            innerHTML: '',
+            className: '',
+            dataset: {},
+            style: {},
+            classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
+            addEventListener() {},
+            removeEventListener() {},
+            querySelectorAll() { return []; },
+            querySelector() { return null; },
+            closest() { return null; },
+            getBoundingClientRect() { return { width: 1000, height: 400, left: 0, top: 0 }; },
+            appendChild(child) { return child; },
+        };
+        elements.set(id, item);
+        return item;
+    }
+    element('capability-inspector-filter');
+    element('capability-inspector-content');
+    element('capability-inspector-empty');
+    element('capability-inspector-summary');
+    element('capability-inspector-refresh');
+    window.document.readyState = 'complete';
+    window.document.getElementById = id => elements.get(id) || null;
+    window.document.querySelectorAll = () => [];
+    window.document.addEventListener = () => {};
+    window.document.createElement = () => element(`created-${elements.size}`);
+    window.requestAnimationFrame = callback => callback();
+    return elements;
+}
+
+module.exports = {
+    ROOT,
+    loadJobs,
+    loadInspector,
+    captureEvents,
+    diagnosticsSnapshot,
+    diagnosticsContributions,
+    storageEntries,
+    dispatch,
+    makeProvider,
+    enqueuePayload,
+    installInspectorDom,
+};
\ No newline at end of file
diff --git a/tests/test_plugin_runtime_idempotence.py b/tests/test_plugin_runtime_idempotence.py
index e1dfc7e..907809c 100644
--- a/tests/test_plugin_runtime_idempotence.py
+++ b/tests/test_plugin_runtime_idempotence.py
@@ -63,8 +63,11 @@ def test_app_shell_loads_capability_registry_before_app_runtime():
 
     assert '<script src="/static/capabilities.js"></script>' in source
     assert '<script src="/static/capabilities/library.js"></script>' in source
+    assert '<script src="/static/capabilities/jobs.js"></script>' in source
     assert source.index('/static/diagnostics.js') < source.index('/static/capabilities.js')
     assert source.index('/static/capabilities.js') < source.index('/static/capabilities/library.js')
+    assert source.index('/static/capabilities/library.js') < source.index('/static/capabilities/jobs.js')
+    assert source.index('/static/capabilities/jobs.js') < source.index('/static/app.js')
     assert source.index('/static/capabilities/library.js') < source.index('/static/app.js')
 
 
@@ -83,7 +86,8 @@ def test_capability_runtime_overrides_do_not_mask_claims():
     set_enabled = source[source.index("function setParticipantEnabled("):source.index("function registerParticipants(")]
     reserved = source[source.index("const RESERVED_FUTURE_DOMAINS"):source.index("const RUNTIME_DOMAIN_DEFAULTS")]
 
-    assert "['denied', 'failed', 'short-circuited', 'handled', 'degraded', 'overridden', 'no-owner', 'no-handler', 'no-target', 'unsupported-command', 'incompatible', 'incompatible-version', 'unavailable', 'provider-selection-required', 'user-action-required', 'stale', 'cancelled', 'stopped'].includes(decision.outcome)" in source
+    for token in ["'unsupported-operation'", "'queued'", "'validation-failed'", "'completed'", "'timeout'", "'retry-started'"]:
+        assert token in source
     assert "if (entry.type !== 'manual') return false;" in source
     assert "type: 'manual'" in source
     assert "_remember(userOverrides" not in set_enabled
@@ -91,7 +95,9 @@ def test_capability_runtime_overrides_do_not_mask_claims():
     assert "'audio-mix'" not in reserved
     assert "'audio-input'" not in reserved
     assert "'playback'" not in reserved
+    assert "'jobs'" not in reserved
     assert "playback:" in source
+    assert "jobs:" in source
     assert "'backend.routes'" in reserved
     assert "'backend.routes':" not in source