# Seqera executor `process.resourceLabels` Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Make the `nf-seqera` executor honour `process.resourceLabels` by sending the config-level baseline as run labels and the per-task delta as Sched task labels.

**Architecture:** Cumulative Nextflow labels split into two scheduler scopes — config-level `process.resourceLabels` becomes `CreateRunRequest.labels`; the difference between `task.config.getResourceLabels()` and that baseline becomes `Task.labels`. The redundant `seqera.executor.labels` config option is removed.

**Tech Stack:** Groovy 4 / Java 21 toolchain, Gradle, Spock, `io.seqera:sched-client` (≥ 0.51.0 — must expose `Task.labels`), Nextflow extension-point plugin model.

**Spec:** `docs/superpowers/specs/2026-04-17-seqera-resource-labels-design.md`

**File map:**
- Modify `settings.gradle` — uncomment-style `includeBuild '../sched'` for dev
- Modify `plugins/nf-seqera/build.gradle` — bump `sched-client` version
- Modify `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy` — add `withProcessResourceLabels`, add `delta`, remove `withUserLabels`
- Modify `plugins/nf-seqera/src/main/io/seqera/config/ExecutorOpts.groovy` — remove `labels` field
- Modify `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy` — wire run labels + cache `runResourceLabels`
- Modify `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraTaskHandler.groovy` — attach delta to `Task.labels`
- Modify `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy`
- Modify `plugins/nf-seqera/src/test/io/seqera/config/ExecutorOptsTest.groovy`
- Modify `plugins/nf-seqera/src/test/io/seqera/executor/SeqeraTaskHandlerTest.groovy`
- Modify `docs/reference/process.md` — add Seqera executor to support list
- Modify `plugins/nf-seqera/changelog.txt` — entry
- Modify `plugins/nf-seqera/VERSION` — bump to `0.18.0`

---

### Task 1: Bump `sched-client` and wire `includeBuild '../sched'`

**Files:**
- Modify: `plugins/nf-seqera/build.gradle:54`
- Modify: `settings.gradle:17-19`

The local `~/Projects/sched` checkout is at `0.51.0`; that is the version exposing `Task.labels`. Until 0.51.0 is published to the Seqera Maven repo, we use a Gradle composite build to substitute the dependency from the local checkout.

- [ ] **Step 1: Bump sched-client version**

Edit `plugins/nf-seqera/build.gradle:54`:

```gradle
    api 'io.seqera:sched-client:0.51.0'
```

- [ ] **Step 2: Add `includeBuild '../sched'` block to `settings.gradle`**

Replace the commented `pluginManagement` block at `settings.gradle:17-19` with both blocks (keep the existing comment, add a new one for sched as dev-only opt-in):

```gradle
// pluginManagement {
//     includeBuild '../nextflow-plugin-gradle'
// }

// For local development against an unpublished sched-client, uncomment:
// includeBuild '../sched'
includeBuild '../sched'
```

(The uncommented `includeBuild '../sched'` line is required for the build to resolve `sched-client:0.51.0` until the artifact is published. The commented hint stays for future reference.)

- [ ] **Step 3: Verify the build resolves**

Run: `./gradlew :plugins:nf-seqera:compileGroovy`
Expected: BUILD SUCCESSFUL. If it fails with a missing `sched-client:0.51.0`, confirm `~/Projects/sched/VERSION` contains `0.51.0` and that `~/Projects/sched/sched-client` builds locally (`cd ~/Projects/sched && ./gradlew :sched-client:assemble`).

- [ ] **Step 4: Commit**

```bash
git add settings.gradle plugins/nf-seqera/build.gradle
git commit -s -m "build(nf-seqera): bump sched-client to 0.51.0 via includeBuild"
```

---

### Task 2: Add `Labels.withProcessResourceLabels` (TDD)

**Files:**
- Modify: `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy`
- Modify: `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy`

- [ ] **Step 1: Write the failing tests**

Append to `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy` (before the closing `}`):

```groovy
    def 'should add process resource labels coercing values to string'() {
        when:
        def labels = new Labels()
                .withProcessResourceLabels([team: 'genomics', priority: 7, retain: true])

        then:
        labels.entries['team'] == 'genomics'
        labels.entries['priority'] == '7'
        labels.entries['retain'] == 'true'
    }

    def 'should ignore null or empty process resource labels'() {
        when:
        def a = new Labels().withProcessResourceLabels(null)
        def b = new Labels().withProcessResourceLabels([:])

        then:
        a.entries.isEmpty()
        b.entries.isEmpty()
    }

    def 'should let process resource labels override workflow metadata on key collision'() {
        given:
        def workflow = Mock(WorkflowMetadata) {
            getProjectName() >> 'hello'
            getRunName() >> 'happy_turing'
            getSessionId() >> UUID.randomUUID()
            isResume() >> false
            getManifest() >> new Manifest([:])
        }

        when:
        def labels = new Labels()
                .withWorkflowMetadata(workflow)
                .withProcessResourceLabels(['nextflow.io/runName': 'custom', team: 'a'])

        then:
        labels.entries['nextflow.io/runName'] == 'custom'
        labels.entries['team'] == 'a'
        labels.entries['nextflow.io/projectName'] == 'hello'
    }
```

- [ ] **Step 2: Run the tests to verify they fail**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.LabelsTest' -i`
Expected: FAIL — `MissingMethodException: No signature of method ... withProcessResourceLabels`.

- [ ] **Step 3: Implement `withProcessResourceLabels`**

Edit `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy`. After the `withUserLabels` method (which will be removed in Task 4), add:

```groovy
    /**
     * Add config-level {@code process.resourceLabels}. Values are coerced to
     * string via {@link String#valueOf} to satisfy the scheduler API typing.
     */
    Labels withProcessResourceLabels(Map<String,?> map) {
        if( !map ) return this
        map.each { k, v -> entries.put(k.toString(), String.valueOf(v)) }
        return this
    }
```

- [ ] **Step 4: Run the tests to verify they pass**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.LabelsTest' -i`
Expected: PASS for the three new tests; existing tests still PASS.

- [ ] **Step 5: Commit**

```bash
git add plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy \
        plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy
git commit -s -m "feat(nf-seqera): add Labels.withProcessResourceLabels"
```

---

### Task 3: Add `Labels.delta` and `Labels.toStringMap` helpers (TDD)

**Files:**
- Modify: `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy`
- Modify: `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy`

These two static helpers compute the per-task delta and coerce arbitrary `Map<String,?>` values to strings — used by both the executor (to cache the run baseline) and the task handler (to compute the delta).

- [ ] **Step 1: Write the failing tests**

Append to `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy` (before the closing `}`):

```groovy
    def 'should coerce map values to strings'() {
        expect:
        Labels.toStringMap(null) == [:]
        Labels.toStringMap([:]) == [:]
        Labels.toStringMap([a: 1, b: 'x', c: true]) == [a: '1', b: 'x', c: 'true']
    }

    def 'should compute null delta when task labels are empty'() {
        expect:
        Labels.delta(null, [team: 'a']) == null
        Labels.delta([:], [team: 'a']) == null
    }

    def 'should return full task labels when run labels are empty'() {
        expect:
        Labels.delta([team: 'a', region: 'us'], null) == [team: 'a', region: 'us']
        Labels.delta([team: 'a', region: 'us'], [:]) == [team: 'a', region: 'us']
    }

    def 'should keep only differing or missing keys in delta'() {
        expect:
        Labels.delta([team: 'a', region: 'us'], [team: 'a']) == [region: 'us']
        Labels.delta([team: 'b'], [team: 'a']) == [team: 'b']
        Labels.delta([team: 'a', region: 'us'], [team: 'a', region: 'us']) == null
    }
```

- [ ] **Step 2: Run the tests to verify they fail**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.LabelsTest' -i`
Expected: FAIL — `MissingMethodException: ... toStringMap` and `... delta`.

- [ ] **Step 3: Implement the helpers**

Edit `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy`. Inside the class, after the existing `runId` method, add:

```groovy
    /**
     * Coerce arbitrary map values to strings via {@link String#valueOf}.
     * Returns an empty map for null/empty input.
     */
    static Map<String,String> toStringMap(Map<String,?> map) {
        if( !map ) return Collections.<String,String>emptyMap()
        final result = new LinkedHashMap<String,String>(map.size())
        map.each { k, v -> result.put(k.toString(), String.valueOf(v)) }
        return result
    }

    /**
     * Return the entries of {@code task} that are missing from {@code run}
     * or have a different value. Returns {@code null} if the resulting
     * map would be empty (so callers can omit the field).
     */
    static Map<String,String> delta(Map<String,String> task, Map<String,String> run) {
        if( !task ) return null
        final result = new LinkedHashMap<String,String>()
        task.each { k, v ->
            if( run == null || !run.containsKey(k) || run.get(k) != v )
                result.put(k, v)
        }
        return result.isEmpty() ? null : result
    }
```

- [ ] **Step 4: Run the tests to verify they pass**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.LabelsTest' -i`
Expected: PASS for all new tests; existing tests still PASS.

- [ ] **Step 5: Commit**

```bash
git add plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy \
        plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy
git commit -s -m "feat(nf-seqera): add Labels.toStringMap and Labels.delta helpers"
```

---

### Task 4: Remove `seqera.executor.labels` config option

**Files:**
- Modify: `plugins/nf-seqera/src/main/io/seqera/config/ExecutorOpts.groovy:74-79,130,168-170`
- Modify: `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy:81-88`
- Modify: `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy:120`
- Modify: `plugins/nf-seqera/src/test/io/seqera/config/ExecutorOptsTest.groovy:131-165`
- Modify: `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy:127-150,192-199`

The user-facing `seqera.executor.labels` option is replaced by the standard Nextflow `process.resourceLabels` directive.

- [ ] **Step 1: Remove the field and getter from `ExecutorOpts`**

Edit `plugins/nf-seqera/src/main/io/seqera/config/ExecutorOpts.groovy`:

Remove lines 74-79 (the `@ConfigOption` block and `final Map<String, String> labels` field):

```groovy
    @ConfigOption
    @Description("""
        Custom labels to apply to AWS resources for cost tracking and resource organization.
        Labels are propagated to ECS tasks, capacity providers, and EC2 instances.
    """)
    final Map<String, String> labels
```

Remove the assignment in the constructor (around line 129-130):

```groovy
        // labels for cost tracking
        this.labels = opts.labels as Map<String, String>
```

Remove the getter (around line 168-170):

```groovy
    Map<String, String> getLabels() {
        return labels
    }
```

- [ ] **Step 2: Remove the `withUserLabels` method from `Labels`**

Edit `plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy`. Delete the entire `withUserLabels` method (lines 81-88):

```groovy
    /**
     * Add user-configured labels. These take precedence over implicit labels.
     */
    Labels withUserLabels(Map<String,String> labels) {
        if( labels )
            entries.putAll(labels)
        return this
    }
```

- [ ] **Step 3: Remove the `withUserLabels` call site in `SeqeraExecutor.createRun()`**

Edit `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy`. Delete the line:

```groovy
        labels.withUserLabels(seqeraConfig.labels)
```

- [ ] **Step 4: Remove obsolete tests**

Edit `plugins/nf-seqera/src/test/io/seqera/config/ExecutorOptsTest.groovy`. Delete the three tests (lines 131-165): `'should create config with labels'`, `'should handle null labels'`, `'should handle empty labels'`.

Edit `plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy`. Delete the two tests: `'should allow user labels to override implicit labels'` (lines 127-150) and `'should handle null user labels'` (lines 192-199).

- [ ] **Step 5: Compile and run tests**

Run: `./gradlew :plugins:nf-seqera:compileGroovy :plugins:nf-seqera:test`
Expected: BUILD SUCCESSFUL; all remaining tests PASS. If the compiler complains about a stray reference to `seqeraConfig.labels` or `withUserLabels`, grep for and remove them: `rg "seqeraConfig\.labels|withUserLabels" plugins/nf-seqera`.

- [ ] **Step 6: Commit**

```bash
git add plugins/nf-seqera/src/main/io/seqera/config/ExecutorOpts.groovy \
        plugins/nf-seqera/src/main/io/seqera/executor/Labels.groovy \
        plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy \
        plugins/nf-seqera/src/test/io/seqera/config/ExecutorOptsTest.groovy \
        plugins/nf-seqera/src/test/io/seqera/executor/LabelsTest.groovy
git commit -s -m "refactor(nf-seqera)!: remove seqera.executor.labels in favour of process.resourceLabels"
```

---

### Task 5: Wire `process.resourceLabels` into `SeqeraExecutor.createRun()` and expose `runResourceLabels` (TDD)

**Files:**
- Modify: `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy`
- Modify: `plugins/nf-seqera/src/test/io/seqera/executor/SeqeraExecutorTest.groovy`

The executor reads the config-level `process.resourceLabels` map once at run creation, attaches it to the run labels via `Labels.withProcessResourceLabels`, and caches the coerced map so task handlers can compute deltas.

- [ ] **Step 1: Write the failing test**

Append to `plugins/nf-seqera/src/test/io/seqera/executor/SeqeraExecutorTest.groovy` (before the final closing `}`):

```groovy
    def 'should expose run resource labels coerced from config-level process.resourceLabels'() {
        given:
        def executor = new SeqeraExecutor()
        executor.@session = Mock(Session) {
            getConfig() >> [process: [resourceLabels: [team: 'a', priority: 7]]]
        }

        when:
        executor.computeRunResourceLabels()

        then:
        executor.runResourceLabels == [team: 'a', priority: '7']
    }

    def 'should yield empty run resource labels when process.resourceLabels is absent'() {
        given:
        def executor = new SeqeraExecutor()
        executor.@session = Mock(Session) {
            getConfig() >> [:]
        }

        when:
        executor.computeRunResourceLabels()

        then:
        executor.runResourceLabels == [:]
    }
```

(`Session` is already imported at line 21; if not, add the import.)

- [ ] **Step 2: Run the test to verify it fails**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.SeqeraExecutorTest' -i`
Expected: FAIL — `computeRunResourceLabels` / `runResourceLabels` don't exist.

- [ ] **Step 3: Implement on `SeqeraExecutor`**

Edit `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy`.

Add a private field near the other private fields (after `runId` at line 65):

```groovy
    private volatile Map<String,String> runResourceLabels = Collections.<String,String>emptyMap()
```

Add a method to compute the run resource labels (place near other protected/package methods, e.g. before `createRun()` at line 110):

```groovy
    @groovy.transform.PackageScope
    void computeRunResourceLabels() {
        final processMap = session.config.process as Map
        final raw = processMap?.get('resourceLabels') as Map<String,?>
        this.runResourceLabels = Labels.toStringMap(raw)
    }
```

Add the public getter (after `getRunId()` around line 204):

```groovy
    Map<String,String> getRunResourceLabels() {
        return runResourceLabels
    }
```

Wire it into `createRun()`. Replace the labels-building block at `SeqeraExecutor.groovy:117-120` (after the deletion in Task 4 it should look like the first three lines below) with:

```groovy
        computeRunResourceLabels()
        final labels = new Labels()
        if( seqeraConfig.autoLabels )
            labels.withWorkflowMetadata(session.workflowMetadata)
        labels.withProcessResourceLabels(runResourceLabels)
```

- [ ] **Step 4: Run the test to verify it passes**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.SeqeraExecutorTest' -i`
Expected: PASS for both new tests; existing tests still PASS.

- [ ] **Step 5: Commit**

```bash
git add plugins/nf-seqera/src/main/io/seqera/executor/SeqeraExecutor.groovy \
        plugins/nf-seqera/src/test/io/seqera/executor/SeqeraExecutorTest.groovy
git commit -s -m "feat(nf-seqera): attach process.resourceLabels to Sched run labels"
```

---

### Task 6: Send per-task delta on `Task.labels` from `SeqeraTaskHandler.submit()` (TDD)

**Files:**
- Modify: `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraTaskHandler.groovy`
- Modify: `plugins/nf-seqera/src/test/io/seqera/executor/SeqeraTaskHandlerTest.groovy`

Capture the `Task` passed to the batch submitter and assert its `labels` field reflects the delta between the task's `getResourceLabels()` and the executor's `runResourceLabels`.

- [ ] **Step 1: Write the failing tests**

Append to `plugins/nf-seqera/src/test/io/seqera/executor/SeqeraTaskHandlerTest.groovy` (before the final closing `}`):

```groovy
    def 'submit attaches Task.labels containing only the per-task delta'() {
        given:
        Task captured = null
        def batchSubmitter = Mock(SeqeraBatchSubmitter) {
            submit(_, _) >> { args -> captured = args[1] as Task }
        }
        def taskConfig = Mock(TaskConfig) {
            getCpus() >> 2
            getMemory() >> MemoryUnit.of('1 GB')
            getAccelerator() >> null
            getResourceLabels() >> [team: 'a', region: 'us-east-1']
            getResourceLimit('memory') >> null
            getResourceLimit('cpus') >> null
            getDisk() >> null
        }
        def taskRun = Mock(TaskRun) {
            getConfig() >> taskConfig
            getWorkDir() >> Paths.get('/work/ab/cd1234')
            getWorkDirStr() >> '/work/ab/cd1234'
            getContainer() >> 'docker.io/library/alpine:3'
            getContainerPlatform() >> 'linux/amd64'
            getId() >> TaskId.of(1)
            getHash() >> HashCode.fromInt(1)
            lazyName() >> 'sample_task'
        }
        def executor = Mock(SeqeraExecutor) {
            getClient() >> Mock(SchedClient)
            getBatchSubmitter() >> batchSubmitter
            getSeqeraConfig() >> Mock(ExecutorOpts) {
                getMachineRequirement() >> Mock(io.seqera.config.MachineRequirementOpts)
                getTaskEnvironment() >> [:]
            }
            getRunResourceLabels() >> [team: 'a']
            ensureRunCreated() >> {}
        }
        def handler = Spy(new SeqeraTaskHandler(taskRun, executor)) {
            fusionEnabled() >> true
            fusionLauncher() >> Mock(nextflow.fusion.FusionScriptLauncher) {
                fusionEnv() >> [:]
            }
            fusionSubmitCli() >> ['/bin/sh', '-c', 'true']
            fusionConfig() >> Mock(nextflow.fusion.FusionConfig) {
                snapshotsEnabled() >> false
            }
        }

        when:
        handler.submit()

        then:
        captured != null
        captured.getLabels() == [region: 'us-east-1']
    }

    def 'submit leaves Task.labels unset when the task labels equal the run baseline'() {
        given:
        Task captured = null
        def batchSubmitter = Mock(SeqeraBatchSubmitter) {
            submit(_, _) >> { args -> captured = args[1] as Task }
        }
        def taskConfig = Mock(TaskConfig) {
            getCpus() >> 2
            getMemory() >> MemoryUnit.of('1 GB')
            getAccelerator() >> null
            getResourceLabels() >> [team: 'a']
            getResourceLimit('memory') >> null
            getResourceLimit('cpus') >> null
            getDisk() >> null
        }
        def taskRun = Mock(TaskRun) {
            getConfig() >> taskConfig
            getWorkDir() >> Paths.get('/work/ab/cd1234')
            getWorkDirStr() >> '/work/ab/cd1234'
            getContainer() >> 'docker.io/library/alpine:3'
            getContainerPlatform() >> 'linux/amd64'
            getId() >> TaskId.of(1)
            getHash() >> HashCode.fromInt(1)
            lazyName() >> 'sample_task'
        }
        def executor = Mock(SeqeraExecutor) {
            getClient() >> Mock(SchedClient)
            getBatchSubmitter() >> batchSubmitter
            getSeqeraConfig() >> Mock(ExecutorOpts) {
                getMachineRequirement() >> Mock(io.seqera.config.MachineRequirementOpts)
                getTaskEnvironment() >> [:]
            }
            getRunResourceLabels() >> [team: 'a']
            ensureRunCreated() >> {}
        }
        def handler = Spy(new SeqeraTaskHandler(taskRun, executor)) {
            fusionEnabled() >> true
            fusionLauncher() >> Mock(nextflow.fusion.FusionScriptLauncher) {
                fusionEnv() >> [:]
            }
            fusionSubmitCli() >> ['/bin/sh', '-c', 'true']
            fusionConfig() >> Mock(nextflow.fusion.FusionConfig) {
                snapshotsEnabled() >> false
            }
        }

        when:
        handler.submit()

        then:
        captured != null
        captured.getLabels() == null
    }
```

- [ ] **Step 2: Run the tests to verify they fail**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.SeqeraTaskHandlerTest' -i`
Expected: FAIL — assertions on `captured.getLabels()` fail because submit() does not set them.

- [ ] **Step 3: Wire the delta into `submit()`**

Edit `plugins/nf-seqera/src/main/io/seqera/executor/SeqeraTaskHandler.groovy`. After the `final schedTask = new Task() ... .nextflow(...)` block ending around line 140, before the `log.debug` call at line 141, insert:

```groovy
        // attach per-task resource labels delta (over run-level baseline)
        final taskLabels = Labels.toStringMap(task.config.getResourceLabels())
        final delta = Labels.delta(taskLabels, executor.runResourceLabels)
        if( delta )
            schedTask.labels(delta)
```

- [ ] **Step 4: Run the tests to verify they pass**

Run: `./gradlew :plugins:nf-seqera:test --tests 'io.seqera.executor.SeqeraTaskHandlerTest' -i`
Expected: PASS for both new tests; existing tests still PASS.

- [ ] **Step 5: Run the full plugin test suite**

Run: `./gradlew :plugins:nf-seqera:test`
Expected: BUILD SUCCESSFUL; no regressions.

- [ ] **Step 6: Commit**

```bash
git add plugins/nf-seqera/src/main/io/seqera/executor/SeqeraTaskHandler.groovy \
        plugins/nf-seqera/src/test/io/seqera/executor/SeqeraTaskHandlerTest.groovy
git commit -s -m "feat(nf-seqera): send per-task resourceLabels delta on Sched task"
```

---

### Task 7: Docs, changelog, and version bump

**Files:**
- Modify: `docs/reference/process.md:1388-1393`
- Modify: `plugins/nf-seqera/changelog.txt`
- Modify: `plugins/nf-seqera/VERSION`

- [ ] **Step 1: Update docs**

Edit `docs/reference/process.md`. Replace the executor support list at lines 1388-1393:

```markdown
Resource labels are currently supported by the following executors:

- {ref}`awsbatch-executor`
- {ref}`azurebatch-executor`
- {ref}`google-batch-executor`
- {ref}`k8s-executor`
- {ref}`seqera-executor`
```

(If `seqera-executor` is not a defined ref, drop the `{ref}` wrapper and write `Seqera executor` as plain text.)

- [ ] **Step 2: Update plugin changelog**

Edit `plugins/nf-seqera/changelog.txt`. Add a new entry at the top, above the `0.17.0` block:

```
0.18.0 - <today's date>
- Support process.resourceLabels: config-level labels attached to Sched run, per-task delta attached to Sched task
- Remove seqera.executor.labels config option (use process.resourceLabels instead)
- Bump sched-client@0.51.0
```

- [ ] **Step 3: Bump plugin VERSION**

Edit `plugins/nf-seqera/VERSION`:

```
0.18.0
```

- [ ] **Step 4: Verify everything builds**

Run: `./gradlew :plugins:nf-seqera:check`
Expected: BUILD SUCCESSFUL.

- [ ] **Step 5: Commit**

```bash
git add docs/reference/process.md plugins/nf-seqera/changelog.txt plugins/nf-seqera/VERSION
git commit -s -m "docs(nf-seqera): document resourceLabels support and bump to 0.18.0"
```

---

## Self-review checklist (executed)

- **Spec coverage:** every section of `2026-04-17-seqera-resource-labels-design.md` maps to a task — sched-client bump (Task 1), `withProcessResourceLabels` (Task 2), `delta` + `toStringMap` (Task 3), removal of `seqera.executor.labels` (Task 4), run-level wiring + `runResourceLabels` (Task 5), per-task delta on `Task.labels` (Task 6), docs / changelog / VERSION (Task 7).
- **Placeholder scan:** no TBDs, no "implement later", every code step has the actual code.
- **Type consistency:** `Labels.toStringMap(Map<String,?>)` and `Labels.delta(Map<String,String>, Map<String,String>)` referenced consistently in Tasks 3, 5, 6; `runResourceLabels` field, `computeRunResourceLabels()` method, and `getRunResourceLabels()` getter consistent across Tasks 5 and 6.