Repository: actions/stale
Pull request #490 (2021-06-07 15:03:28)

build(deps-dev): bump typescript from 4.2.4 to 4.3.2
Bumps [typescript](https://github.com/Microsoft/TypeScript) from 4.2.4 to 4.3.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/Microsoft/TypeScript/releases">typescript's releases</a>.</em></p>
<blockquote>
<h2>TypeScript 4.3.2</h2>
<p>For release notes, check out the <a href="https://devblogs.microsoft.com/typescript/announcing-typescript-4-3">release announcement</a>.</p>
<p>For the complete list of fixed issues, check out the</p>
<ul>
<li><a href="https://github.com/Microsoft/TypeScript/issues?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3A%22TypeScript+4.3.0%22+is%3Aclosed+">fixed issues query for TypeScript v4.3.0 (Beta)</a>.</li>
<li><a href="https://github.com/Microsoft/TypeScript/issues?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3A%22TypeScript+4.3.1%22+is%3Aclosed+">fixed issues query for TypeScript v4.3.1 (RC)</a>.</li>
<li><a href="https://github.com/Microsoft/TypeScript/issues?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3A%22TypeScript+4.3.2%22+is%3Aclosed+">fixed issues query for TypeScript v4.3.2</a>.</li>
</ul>
<p>Downloads are available on:</p>
<ul>
<li><a href="https://www.npmjs.com/package/typescript">npm</a></li>
<li><a href="https://marketplace.visualstudio.com/items?itemName=TypeScriptTeam.TypeScript-43">Visual Studio 2017/2019</a> (<a href="https://github.com/Microsoft/TypeScript/wiki/Updating-TypeScript-in-Visual-Studio-2017">Select new version in project options</a>)</li>
<li><a href="https://www.nuget.org/packages/Microsoft.TypeScript.MSBuild">NuGet package</a></li>
</ul>
<h2>TypeScript 4.3 RC</h2>
<p>For release notes, check out the <a href="https://devblogs.microsoft.com/typescript/announcing-typescript-4-3-rc">release announcement</a>.</p>
<p>For the complete list of fixed issues, check out the</p>
<ul>
<li><a href="https://github.com/Microsoft/TypeScript/issues?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3A%22TypeScript+4.3.0%22+is%3Aclosed+">fixed issues query for TypeScript v4.3.0 (Beta)</a>.</li>
<li><a href="https://github.com/Microsoft/TypeScript/issues?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3A%22TypeScript+4.3.1%22+is%3Aclosed+">fixed issues query for TypeScript v4.3.1 (RC)</a>.</li>
</ul>
<p>Downloads are available on:</p>
<ul>
<li><a href="https://www.npmjs.com/package/typescript">npm</a></li>
<li><a href="https://marketplace.visualstudio.com/items?itemName=TypeScriptTeam.TypeScript-43">Visual Studio 2017/2019</a> (<a href="https://github.com/Microsoft/TypeScript/wiki/Updating-TypeScript-in-Visual-Studio-2017">Select new version in project options</a>)</li>
<li><a href="https://www.nuget.org/packages/Microsoft.TypeScript.MSBuild">NuGet package</a></li>
</ul>
<h2>TypeScript 4.3 Beta</h2>
<p>For release notes, check out the <a href="https://devblogs.microsoft.com/typescript/announcing-typescript-4-3-beta/">release announcement</a>.</p>
<p>For the complete list of fixed issues, check out the</p>
<ul>
<li><a href="https://github.com/Microsoft/TypeScript/issues?q=milestone%3A%22TypeScript+4.3.0%22">fixed issues query for Typescript 4.3.0 (Beta)</a>.</li>
</ul>
<p>Downloads are available on:</p>
<ul>
<li><a href="https://www.npmjs.com/package/typescript">npm</a></li>
<li><a href="https://marketplace.visualstudio.com/items?itemName=TypeScriptTeam.TypeScript-43beta">Visual Studio 2017/2019</a> (<a href="https://github.com/Microsoft/TypeScript/wiki/Updating-TypeScript-in-Visual-Studio-2017">Select new version in project options</a>)</li>
<li><a href="https://www.nuget.org/packages/Microsoft.TypeScript.MSBuild">NuGet package</a></li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/microsoft/TypeScript/commit/28e3e6ff2f49f1dbf06d31809ec73dbe42f1aa63"><code>28e3e6f</code></a> 🤖 Pick PR <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44219">#44219</a> (Properly remove generic types that ...) into release-4.3 (#...</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/d6e6fa728e1ab34aa46573152d274f067afc9b6f"><code>d6e6fa7</code></a> Cherry-pick PR <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44129">#44129</a> into release-4.3 (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44240">#44240</a>)</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/27d6e4490d291adc33730d1a5d73ba52d78602d9"><code>27d6e44</code></a> Bump version to 4.3.2 and LKG</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/fed23150621413624df627a4ab667a7fae557dbd"><code>fed2315</code></a> Cherry-pick PR <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44186">#44186</a> into release-4.3 (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44188">#44188</a>)</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/dec82611743ad357d63dd0999774c98710e5f69a"><code>dec8261</code></a> Revert <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/43460">#43460</a> and <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/40884">#40884</a> (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44175">#44175</a>) (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44177">#44177</a>)</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/22c3c24cf0676219c93b7a16964d4c453ad4f064"><code>22c3c24</code></a> Cherry-pick PR <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44125">#44125</a> into release-4.3 (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44136">#44136</a>)</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/1d850c0927107d0f0f1efdfc3c160436ed010c92"><code>1d850c0</code></a> Cherry-pick PR <a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44008">#44008</a> into release-4.3 (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44029">#44029</a>)</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/d805ce877ae6235565ee697c3c0ce8a95a9c58f6"><code>d805ce8</code></a> Bump version to 4.3.1-rc and LKG</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/bab601b5e60d47a8b345872643fcb51699ae6edd"><code>bab601b</code></a> Merge remote-tracking branch 'origin/master' into release-4.3</li>
<li><a href="https://github.com/microsoft/TypeScript/commit/5b1e873b031f7c82cef0bc837c3656a4474fdb35"><code>5b1e873</code></a> Update diagnostic message and quickfix for parameter property (<a href="https://github-redirect.dependabot.com/Microsoft/TypeScript/issues/44010">#44010</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/Microsoft/TypeScript/compare/v4.2.4...v4.3.2">compare view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=typescript&package-manager=npm_and_yarn&previous-version=4.2.4&new-version=4.3.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)


</details>


Patch:
diff --git a/README.md b/README.md
index 07a5b98..5dd6e7f 100644
--- a/README.md
+++ b/README.md
@@ -8,58 +8,84 @@ The default configuration will:
 - Close the stale issues and pull requests after 7 days of inactivity
 - If an update/comment occur on stale issues or pull requests, the stale label will be removed and the timer will restart
 
+## Recommended permissions
+
+For the execution of this action, it must be able to fetch all issues and pull requests from your repository.  
+This can be achieved with the following [configuration in the action](https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#permissions) if the permissions are restricted:
+
+```yaml
+permissions:
+  issues: read
+  pull-requests: read
+```
+  
+In addition, based on the provided configuration, the action could require more permission(s) (e.g.: add label, remove label, comment, close, etc.).  
+You can find more information about the required permissions under the corresponding options that you wish to use.  
+However, if don't want to bother, you can use these permissions:
+
+```yaml
+permissions:
+  issues: write
+  pull-requests: write
+```
+
 ## All options
 
 ### List of input options
 
 Every argument is optional.
 
-| Input                                                               | Description                                                              | Default               |
-| ------------------------------------------------------------------- | ------------------------------------------------------------------------ | --------------------- |
-| [repo-token](#repo-token)                                           | PAT for GitHub API authentication                                        | `${{ github.token }}` |
-| [days-before-stale](#days-before-stale)                             | Idle number of days before marking issues/PRs stale                      | `60`                  |
-| [days-before-issue-stale](#days-before-issue-stale)                 | Override [days-before-stale](#days-before-stale) for issues only         |                       |
-| [days-before-pr-stale](#days-before-pr-stale)                       | Override [days-before-stale](#days-before-stale) for PRs only            |                       |
-| [days-before-close](#days-before-close)                             | Idle number of days before closing stale issues/PRs                      | `7`                   |
-| [days-before-issue-close](#days-before-issue-close)                 | Override [days-before-close](#days-before-close) for issues only         |                       |
-| [days-before-pr-close](#days-before-pr-close)                       | Override [days-before-close](#days-before-close) for PRs only            |                       |
-| [stale-issue-message](#stale-issue-message)                         | Comment on the staled issues                                             |                       |
-| [stale-pr-message](#stale-pr-message)                               | Comment on the staled PRs                                                |                       |
-| [close-issue-message](#close-issue-message)                         | Comment on the staled issues while closed                                |                       |
-| [close-pr-message](#close-pr-message)                               | Comment on the staled PRs while closed                                   |                       |
-| [stale-issue-label](#stale-issue-label)                             | Label to apply on staled issues                                          | `Stale`               |
-| [close-issue-label](#close-issue-label)                             | Label to apply on closed issues                                          |                       |
-| [stale-pr-label](#stale-pr-label)                                   | Label to apply on staled PRs                                             | `Stale`               |
-| [close-pr-label](#close-pr-label)                                   | Label to apply on closed PRs                                             |                       |
-| [exempt-issue-labels](#exempt-issue-labels)                         | Labels on issues exempted from stale                                     |                       |
-| [exempt-pr-labels](#exempt-pr-labels)                               | Labels on PRs exempted from stale                                        |                       |
-| [only-labels](#only-labels)                                         | Only issues/PRs with ALL these labels are checked                        |                       |
-| [only-issue-labels](#only-issue-labels)                             | Only issues with ALL these labels are checked                            |                       |
-| [only-pr-labels](#only-pr-labels)                                   | Only PRs with ALL these labels are checked                               |                       |
-| [any-of-labels](#any-of-labels)                                     | Only issues/PRs with ANY of these labels are checked                     |                       |
-| [any-of-issue-labels](#any-of-issue-labels)                         | Only issues with ANY of these labels are checked                         |                       |
-| [any-of-pr-labels](#any-of-pr-labels)                               | Only PRs with ANY of these labels are checked                            |                       |
-| [operations-per-run](#operations-per-run)                           | Max number of operations per run                                         | `30`                  |
-| [remove-stale-when-updated](#remove-stale-when-updated)             | Remove stale label from issues/PRs on updates/comments                   | `true`                |
-| [remove-issue-stale-when-updated](#remove-issue-stale-when-updated) | Remove stale label from issues on updates/comments                       |                       |
-| [remove-pr-stale-when-updated](#remove-pr-stale-when-updated)       | Remove stale label from PRs on updates/comments                          |                       |
-| [debug-only](#debug-only)                                           | Dry-run                                                                  | `false`               |
-| [ascending](#ascending)                                             | Order to get issues/PRs                                                  | `false`               |
-| [start-date](#start-date)                                           | Skip stale action for issues/PRs created before it                       |                       |
-| [delete-branch](#delete-branch)                                     | Delete branch after closing a stale PR                                   | `false`               |
-| [exempt-milestones](#exempt-milestones)                             | Milestones on issues/PRs exempted from stale                             |                       |
-| [exempt-issue-milestones](#exempt-issue-milestones)                 | Override [exempt-milestones](#exempt-milestones) for issues only         |                       |
-| [exempt-pr-milestones](#exempt-pr-milestones)                       | Override [exempt-milestones](#exempt-milestones) for PRs only            |                       |
-| [exempt-all-milestones](#exempt-all-milestones)                     | Exempt all issues/PRs with milestones from stale                         |                       |
-| [exempt-all-issue-milestones](#exempt-all-issue-milestones)         | Override [exempt-all-milestones](#exempt-all-milestones) for issues only |                       |
-| [exempt-all-pr-milestones](#exempt-all-pr-milestones)               | Override [exempt-all-milestones](#exempt-all-milestones) for PRs only    |                       |
-| [exempt-assignees](#exempt-assignees)                               | Assignees on issues/PRs exempted from stale                              |                       |
-| [exempt-issue-assignees](#exempt-issue-assignees)                   | Override [exempt-assignees](#exempt-assignees) for issues only           |                       |
-| [exempt-pr-assignees](#exempt-pr-assignees)                         | Override [exempt-assignees](#exempt-assignees) for PRs only              |                       |
-| [exempt-all-assignees](#exempt-all-assignees)                       | Exempt all issues/PRs with assignees from stale                          |                       |
-| [exempt-all-issue-assignees](#exempt-all-issue-assignees)           | Override [exempt-all-assignees](#exempt-all-assignees) for issues only   |                       |
-| [exempt-all-pr-assignees](#exempt-all-pr-assignees)                 | Override [exempt-all-assignees](#exempt-all-assignees) for PRs only      |                       |
-| [enable-statistics](#enable-statistics)                             | Display statistics in the logs                                           | `true`                |
+| Input                                                                   | Description                                                                          | Default               |
+| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | --------------------- |
+| [repo-token](#repo-token)                                               | PAT for GitHub API authentication                                                    | `${{ github.token }}` |
+| [days-before-stale](#days-before-stale)                                 | Idle number of days before marking issues/PRs stale                                  | `60`                  |
+| [days-before-issue-stale](#days-before-issue-stale)                     | Override [days-before-stale](#days-before-stale) for issues only                     |                       |
+| [days-before-pr-stale](#days-before-pr-stale)                           | Override [days-before-stale](#days-before-stale) for PRs only                        |                       |
+| [days-before-close](#days-before-close)                                 | Idle number of days before closing stale issues/PRs                                  | `7`                   |
+| [days-before-issue-close](#days-before-issue-close)                     | Override [days-before-close](#days-before-close) for issues only                     |                       |
+| [days-before-pr-close](#days-before-pr-close)                           | Override [days-before-close](#days-before-close) for PRs only                        |                       |
+| [stale-issue-message](#stale-issue-message)                             | Comment on the staled issues                                                         |                       |
+| [stale-pr-message](#stale-pr-message)                                   | Comment on the staled PRs                                                            |                       |
+| [close-issue-message](#close-issue-message)                             | Comment on the staled issues while closed                                            |                       |
+| [close-pr-message](#close-pr-message)                                   | Comment on the staled PRs while closed                                               |                       |
+| [stale-issue-label](#stale-issue-label)                                 | Label to apply on staled issues                                                      | `Stale`               |
+| [close-issue-label](#close-issue-label)                                 | Label to apply on closed issues                                                      |                       |
+| [stale-pr-label](#stale-pr-label)                                       | Label to apply on staled PRs                                                         | `Stale`               |
+| [close-pr-label](#close-pr-label)                                       | Label to apply on closed PRs                                                         |                       |
+| [exempt-issue-labels](#exempt-issue-labels)                             | Labels on issues exempted from stale                                                 |                       |
+| [exempt-pr-labels](#exempt-pr-labels)                                   | Labels on PRs exempted from stale                                                    |                       |
+| [only-labels](#only-labels)                                             | Only issues/PRs with ALL these labels are checked                                    |                       |
+| [only-issue-labels](#only-issue-labels)                                 | Only issues with ALL these labels are checked                                        |                       |
+| [only-pr-labels](#only-pr-labels)                                       | Only PRs with ALL these labels are checked                                           |                       |
+| [any-of-labels](#any-of-labels)                                         | Only issues/PRs with ANY of these labels are checked                                 |                       |
+| [any-of-issue-labels](#any-of-issue-labels)                             | Only issues with ANY of these labels are checked                                     |                       |
+| [any-of-pr-labels](#any-of-pr-labels)                                   | Only PRs with ANY of these labels are checked                                        |                       |
+| [operations-per-run](#operations-per-run)                               | Max number of operations per run                                                     | `30`                  |
+| [remove-stale-when-updated](#remove-stale-when-updated)                 | Remove stale label from issues/PRs on updates                                        | `true`                |
+| [remove-issue-stale-when-updated](#remove-issue-stale-when-updated)     | Override [remove-stale-when-updated](#remove-stale-when-updated) for issues only     |                       |
+| [remove-pr-stale-when-updated](#remove-pr-stale-when-updated)           | Override [remove-stale-when-updated](#remove-stale-when-updated) for PRs only        |                       |
+| [remove-stale-when-commented](#remove-stale-when-commented)             | Remove stale label from issues/PRs on comments                                       | `true`                |
+| [remove-issue-stale-when-commented](#remove-issue-stale-when-commented) | Override [remove-stale-when-commented](#remove-stale-when-commented) for issues only |                       |
+| [remove-pr-stale-when-commented](#remove-pr-stale-when-commented)       | Override [remove-stale-when-commented](#remove-stale-when-commented) for PRs only    |                       |
+| [labels-to-add-when-unstale](#labels-to-add-when-unstale)               | Add specified labels from issues/PRs when they become unstale                        |                       |
+| [labels-to-remove-when-unstale](#labels-to-remove-when-unstale)         | Remove specified labels from issues/PRs when they become unstale                     |                       |
+| [debug-only](#debug-only)                                               | Dry-run                                                                              | `false`               |
+| [ascending](#ascending)                                                 | Order to get issues/PRs                                                              | `false`               |
+| [start-date](#start-date)                                               | Skip stale action for issues/PRs created before it                                   |                       |
+| [delete-branch](#delete-branch)                                         | Delete branch after closing a stale PR                                               | `false`               |
+| [exempt-milestones](#exempt-milestones)                                 | Milestones on issues/PRs exempted from stale                                         |                       |
+| [exempt-issue-milestones](#exempt-issue-milestones)                     | Override [exempt-milestones](#exempt-milestones) for issues only                     |                       |
+| [exempt-pr-milestones](#exempt-pr-milestones)                           | Override [exempt-milestones](#exempt-milestones) for PRs only                        |                       |
+| [exempt-all-milestones](#exempt-all-milestones)                         | Exempt all issues/PRs with milestones from stale                                     |                       |
+| [exempt-all-issue-milestones](#exempt-all-issue-milestones)             | Override [exempt-all-milestones](#exempt-all-milestones) for issues only             |                       |
+| [exempt-all-pr-milestones](#exempt-all-pr-milestones)                   | Override [exempt-all-milestones](#exempt-all-milestones) for PRs only                |                       |
+| [exempt-assignees](#exempt-assignees)                                   | Assignees on issues/PRs exempted from stale                                          |                       |
+| [exempt-issue-assignees](#exempt-issue-assignees)                       | Override [exempt-assignees](#exempt-assignees) for issues only                       |                       |
+| [exempt-pr-assignees](#exempt-pr-assignees)                             | Override [exempt-assignees](#exempt-assignees) for PRs only                          |                       |
+| [exempt-all-assignees](#exempt-all-assignees)                           | Exempt all issues/PRs with assignees from stale                                      |                       |
+| [exempt-all-issue-assignees](#exempt-all-issue-assignees)               | Override [exempt-all-assignees](#exempt-all-assignees) for issues only               |                       |
+| [exempt-all-pr-assignees](#exempt-all-pr-assignees)                     | Override [exempt-all-assignees](#exempt-all-assignees) for PRs only                  |                       |
+| [enable-statistics](#enable-statistics)                                 | Display statistics in the logs                                                       | `true`                |
 
 ### List of output options
 
@@ -154,7 +180,8 @@ The message that will be added as a comment to the issues when the stale workflo
 
 You can skip the comment sending by omitting the option or by passing an empty string.
 
-Default value: unset
+Default value: unset  
+Required Permission: `issues: write`
 
 #### stale-pr-message
 
@@ -162,47 +189,54 @@ The message that will be added as a comment to the pull requests when the stale
 
 You can skip the comment sending by omitting the option or by passing an empty string.
 
-Default value: unset
+Default value: unset  
+Required Permission: `pull-requests: write`
 
 #### close-issue-message
 
 The message that will be added as a comment to the issues when the stale workflow closes it automatically after being stale for too long.
 
-Default value: unset
+Default value: unset  
+Required Permission: `issues: write`
 
 #### close-pr-message
 
 The message that will be added as a comment to the pull requests when the stale workflow closes it automatically after being stale for too long.
 
-Default value: unset
+Default value: unset  
+Required Permission: `pull-requests: write`
 
 #### stale-issue-label
 
 The label that will be added to the issues when automatically marked as stale.  
 If you wish to speedup the stale workflow for the issues, you can add this label manually to mark as stale.
 
-Default value: `Stale`
+Default value: `Stale`  
+Required Permission: `issues: write`
 
 #### close-issue-label
 
 The label that will be added to the issues when closed automatically.  
 It will be automatically removed if the issues are no longer closed nor locked.
 
-Default value: unset
+Default value: unset  
+Required Permission: `issues: write`
 
 #### stale-pr-label
 
 The label that will be added to the pull requests when automatically marked as stale.  
 If you wish to speedup the stale workflow for the pull requests, you can add this label manually to mark as stale.
 
-Default value: `Stale`
+Default value: `Stale`  
+Required Permission: `pull-requests: write`
 
 #### close-pr-label
 
 The label that will be added to the pull requests when closed automatically.  
 It will be automatically removed if the pull requests are no longer closed nor locked.
 
-Default value: unset
+Default value: unset  
+Required Permission: `pull-requests: write`
 
 #### exempt-issue-labels
 
@@ -291,22 +325,60 @@ Default value: `30`
 
 #### remove-stale-when-updated
 
-Automatically remove the stale label when the issues or the pull requests are updated (based on [GitHub issue](https://docs.github.com/en/rest/reference/issues) field `updated_at`) or commented.
+Automatically remove the stale label when the issues or the pull requests are updated (based on [GitHub issue](https://docs.github.com/en/rest/reference/issues) field `updated_at`).
 
-Default value: `true`
+Default value: `true`  
+Required Permission: `issues: write` and `pull-requests: write`
 
 #### remove-issue-stale-when-updated
 
-Override [remove-stale-when-updated](#remove-stale-when-updated) but only to automatically remove the stale label when the issues are updated (based on [GitHub issue](https://docs.github.com/en/rest/reference/issues) field `updated_at`) or commented.
+Override [remove-stale-when-updated](#remove-stale-when-updated) but only to automatically remove the stale label when the issues are updated (based on [GitHub issue](https://docs.github.com/en/rest/reference/issues) field `updated_at`).
 
-Default value: unset
+Default value: unset  
+Required Permission: `issues: write`
 
 #### remove-pr-stale-when-updated
 
-Override [remove-stale-when-updated](#remove-stale-when-updated) but only to automatically remove the stale label when the pull requests are updated (based on [GitHub issue](https://docs.github.com/en/rest/reference/issues) field `updated_at`) or commented.
+Override [remove-stale-when-updated](#remove-stale-when-updated) but only to automatically remove the stale label when the pull requests are updated (based on [GitHub issue](https://docs.github.com/en/rest/reference/issues) field `updated_at`).
+
+Default value: unset
+
+#### remove-stale-when-commented
+
+Automatically remove the stale label when the issues or the pull requests are commented.
+
+Default value: `true`  
+Required Permission: `issues: write` and `pull-requests: write`
+
+#### remove-issue-stale-when-commented
+
+Override [remove-stale-when-commented](#remove-stale-when-commented) but only to automatically remove the stale label when the issues are commented.
+
+Default value: unset  
+Required Permission: `issues: write` and `pull-requests: write`
+
+#### remove-pr-stale-when-commented
+
+Override [remove-stale-when-commented](#remove-stale-when-commented) but only to automatically remove the stale label when the pull requests are commented.
+
+Default value: unset  
+Required Permission: `issues: write` and `pull-requests: write`
+
+#### labels-to-add-when-unstale
+
+A comma delimited list of labels to add when a stale issue or pull request receives activity and has the [stale-issue-label](#stale-issue-label) or [stale-pr-label](#stale-pr-label) removed from it.
 
 Default value: unset
 
+#### labels-to-remove-when-unstale
+
+A comma delimited list of labels to remove when a stale issue or pull request receives activity and has the [stale-issue-label](#stale-issue-label) or [stale-pr-label](#stale-pr-label) removed from it.
+
+Warning: each label results in a unique API call which can drastically consume the limit of [operations-per-run](#operations-per-run).
+
+Default value: unset  
+Required Permission: `pull-requests: write`
+
 #### debug-only
 
 Run the stale workflow as dry-run.  
@@ -340,7 +412,8 @@ Default value: unset
 
 If set to `true`, the stale workflow will automatically delete the GitHub branches related to the pull requests automatically closed by the stale workflow.
 
-Default value: `false`
+Default value: `false`  
+Required Permission: `pull-requests: write`
 
 #### exempt-milestones
 
diff --git a/action.yml b/action.yml
index 4adb85a..d346279 100644
--- a/action.yml
+++ b/action.yml
@@ -113,15 +113,27 @@ inputs:
     default: '30'
     required: false
   remove-stale-when-updated:
-    description: 'Remove stale labels from issues and pull requests when they are updated or commented on.'
+    description: 'Remove stale labels from issues and pull requests when they are updated.'
     default: 'true'
     required: false
   remove-issue-stale-when-updated:
-    description: 'Remove stale labels from issues when they are updated or commented on. Override "remove-stale-when-updated" option regarding only the issues.'
+    description: 'Remove stale labels from issues when they are updated. Override "remove-stale-when-updated" option regarding only the issues.'
     default: ''
     required: false
   remove-pr-stale-when-updated:
-    description: 'Remove stale labels from pull requests when they are updated or commented on. Override "remove-stale-when-updated" option regarding only the pull requests.'
+    description: 'Remove stale labels from pull requests when they are updated. Override "remove-stale-when-updated" option regarding only the pull requests.'
+    default: ''
+    required: false
+  remove-stale-when-commented:
+    description: 'Remove stale labels from issues and pull requests when they are commented on.'
+    default: 'true'
+    required: false
+  remove-issue-stale-when-commented:
+    description: 'Remove stale labels from issues when they are commented on. Override "remove-stale-when-commented" option regarding only the issues.'
+    default: ''
+    required: false
+  remove-pr-stale-when-commented:
+    description: 'Remove stale labels from pull requests when they are commented on. Override "remove-stale-when-commented" option regarding only the pull requests.'
     default: ''
     required: false
   debug-only:
diff --git a/dist/index.js b/dist/index.js
index f228e1f..0968b22 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -253,9 +253,10 @@ class IssuesProcessor {
         this.closedIssues = [];
         this.deletedBranchIssues = [];
         this.removedLabelIssues = [];
+        this.addedLabelIssues = [];
         this.options = options;
         this.client = github_1.getOctokit(this.options.repoToken);
-        this._operations = new stale_operations_1.StaleOperations(this.options);
+        this.operations = new stale_operations_1.StaleOperations(this.options);
         this._logger.info(logger_service_1.LoggerService.yellow(`Starting the stale action process...`));
         if (this.options.debugOnly) {
             this._logger.warning(logger_service_1.LoggerService.yellowBright(`Executing in debug mode!`));
@@ -293,171 +294,187 @@ class IssuesProcessor {
             const actor = yield this.getActor();
             if (issues.length <= 0) {
                 this._logger.info(logger_service_1.LoggerService.green(`No more issues found to process. Exiting...`));
-                (_a = this._statistics) === null || _a === void 0 ? void 0 : _a.setRemainingOperations(this._operations.getRemainingOperationsCount()).logStats();
-                return this._operations.getRemainingOperationsCount();
+                (_a = this._statistics) === null || _a === void 0 ? void 0 : _a.setOperationsCount(this.operations.getConsumedOperationsCount()).logStats();
+                return this.operations.getRemainingOperationsCount();
             }
             else {
                 this._logger.info(`${logger_service_1.LoggerService.yellow('Processing the batch of issues')} ${logger_service_1.LoggerService.cyan(`#${page}`)} ${logger_service_1.LoggerService.yellow('containing')} ${logger_service_1.LoggerService.cyan(issues.length)} ${logger_service_1.LoggerService.yellow(`issue${issues.length > 1 ? 's' : ''}...`)}`);
             }
+            const labelsToAddWhenUnstale = words_to_list_1.wordsToList(this.options.labelsToAddWhenUnstale);
+            const labelsToRemoveWhenUnstale = words_to_list_1.wordsToList(this.options.labelsToRemoveWhenUnstale);
             for (const issue of issues.values()) {
+                // Stop the processing if no more operations remains
+                if (!this.operations.hasRemainingOperations()) {
+                    break;
+                }
                 const issueLogger = new issue_logger_1.IssueLogger(issue);
-                (_b = this._statistics) === null || _b === void 0 ? void 0 : _b.incrementProcessedItemsCount(issue);
-                issueLogger.info(`Found this $$type last updated at: ${logger_service_1.LoggerService.cyan(issue.updated_at)}`);
-                // calculate string based messages for this issue
-                const staleMessage = issue.isPullRequest
-                    ? this.options.stalePrMessage
-                    : this.options.staleIssueMessage;
-                const closeMessage = issue.isPullRequest
-                    ? this.options.closePrMessage
-                    : this.options.closeIssueMessage;
-                const staleLabel = issue.isPullRequest
-                    ? this.options.stalePrLabel
-                    : this.options.staleIssueLabel;
-                const closeLabel = issue.isPullRequest
-                    ? this.options.closePrLabel
-                    : this.options.closeIssueLabel;
-                const skipMessage = issue.isPullRequest
-                    ? this.options.stalePrMessage.length === 0
-                    : this.options.staleIssueMessage.length === 0;
-                const daysBeforeStale = issue.isPullRequest
-                    ? this._getDaysBeforePrStale()
-                    : this._getDaysBeforeIssueStale();
-                const onlyLabels = words_to_list_1.wordsToList(this._getOnlyLabels(issue));
-                if (onlyLabels.length > 0) {
-                    issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.OnlyLabels)} was specified to only process issues and pull requests with all those labels (${logger_service_1.LoggerService.cyan(onlyLabels.length)})`);
-                    const hasAllWhitelistedLabels = onlyLabels.every((label) => {
-                        return is_labeled_1.isLabeled(issue, label);
-                    });
-                    if (!hasAllWhitelistedLabels) {
-                        issueLogger.info(logger_service_1.LoggerService.white('└──'), `Skipping this $$type because it doesn't have all the required labels`);
-                        IssuesProcessor._endIssueProcessing(issue);
-                        continue; // Don't process issues without all of the required labels
-                    }
-                    else {
-                        issueLogger.info(logger_service_1.LoggerService.white('├──'), `All the required labels are present on this $$type`);
-                        issueLogger.info(logger_service_1.LoggerService.white('└──'), `Continuing the process for this $$type`);
-                    }
+                yield issueLogger.grouping(`$$type #${issue.number}`, () => __awaiter(this, void 0, void 0, function* () {
+                    yield this.processIssue(issue, actor, labelsToAddWhenUnstale, labelsToRemoveWhenUnstale);
+                }));
+            }
+            if (!this.operations.hasRemainingOperations()) {
+                this._logger.warning(logger_service_1.LoggerService.yellowBright(`No more operations left! Exiting...`));
+                this._logger.warning(`${logger_service_1.LoggerService.yellowBright('If you think that not enough issues were processed you could try to increase the quantity related to the')} ${this._logger.createOptionLink(option_1.Option.OperationsPerRun)} ${logger_service_1.LoggerService.yellowBright('option which is currently set to')} ${logger_service_1.LoggerService.cyan(this.options.operationsPerRun)}`);
+                (_b = this._statistics) === null || _b === void 0 ? void 0 : _b.setOperationsCount(this.operations.getConsumedOperationsCount()).logStats();
+                return 0;
+            }
+            this._logger.info(`${logger_service_1.LoggerService.green('Batch')} ${logger_service_1.LoggerService.cyan(`#${page}`)} ${logger_service_1.LoggerService.green('processed.')}`);
+            // Do the next batch
+            return this.processIssues(page + 1);
+        });
+    }
+    processIssue(issue, actor, labelsToAddWhenUnstale, labelsToRemoveWhenUnstale) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this._statistics) === null || _a === void 0 ? void 0 : _a.incrementProcessedItemsCount(issue);
+            const issueLogger = new issue_logger_1.IssueLogger(issue);
+            issueLogger.info(`Found this $$type last updated at: ${logger_service_1.LoggerService.cyan(issue.updated_at)}`);
+            // calculate string based messages for this issue
+            const staleMessage = issue.isPullRequest
+                ? this.options.stalePrMessage
+                : this.options.staleIssueMessage;
+            const closeMessage = issue.isPullRequest
+                ? this.options.closePrMessage
+                : this.options.closeIssueMessage;
+            const staleLabel = issue.isPullRequest
+                ? this.options.stalePrLabel
+                : this.options.staleIssueLabel;
+            const closeLabel = issue.isPullRequest
+                ? this.options.closePrLabel
+                : this.options.closeIssueLabel;
+            const skipMessage = issue.isPullRequest
+                ? this.options.stalePrMessage.length === 0
+                : this.options.staleIssueMessage.length === 0;
+            const daysBeforeStale = issue.isPullRequest
+                ? this._getDaysBeforePrStale()
+                : this._getDaysBeforeIssueStale();
+            const onlyLabels = words_to_list_1.wordsToList(this._getOnlyLabels(issue));
+            if (onlyLabels.length > 0) {
+                issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.OnlyLabels)} was specified to only process issues and pull requests with all those labels (${logger_service_1.LoggerService.cyan(onlyLabels.length)})`);
+                const hasAllWhitelistedLabels = onlyLabels.every((label) => {
+                    return is_labeled_1.isLabeled(issue, label);
+                });
+                if (!hasAllWhitelistedLabels) {
+                    issueLogger.info(logger_service_1.LoggerService.white('└──'), `Skipping this $$type because it doesn't have all the required labels`);
+                    IssuesProcessor._endIssueProcessing(issue);
+                    return; // Don't process issues without all of the required labels
                 }
                 else {
-                    issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.OnlyLabels)} was not specified`);
+                    issueLogger.info(logger_service_1.LoggerService.white('├──'), `All the required labels are present on this $$type`);
                     issueLogger.info(logger_service_1.LoggerService.white('└──'), `Continuing the process for this $$type`);
                 }
-                issueLogger.info(`Days before $$type stale: ${logger_service_1.LoggerService.cyan(daysBeforeStale)}`);
-                const shouldMarkAsStale = should_mark_when_stale_1.shouldMarkWhenStale(daysBeforeStale);
-                if (issue.state === 'closed') {
-                    issueLogger.info(`Skipping this $$type because it is closed`);
+            }
+            else {
+                issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.OnlyLabels)} was not specified`);
+                issueLogger.info(logger_service_1.LoggerService.white('└──'), `Continuing the process for this $$type`);
+            }
+            issueLogger.info(`Days before $$type stale: ${logger_service_1.LoggerService.cyan(daysBeforeStale)}`);
+            const shouldMarkAsStale = should_mark_when_stale_1.shouldMarkWhenStale(daysBeforeStale);
+            if (issue.state === 'closed') {
+                issueLogger.info(`Skipping this $$type because it is closed`);
+                IssuesProcessor._endIssueProcessing(issue);
+                return; // Don't process closed issues
+            }
+            if (issue.locked) {
+                issueLogger.info(`Skipping this $$type because it is locked`);
+                IssuesProcessor._endIssueProcessing(issue);
+                return; // Don't process locked issues
+            }
+            // Try to remove the close label when not close/locked issue or PR
+            yield this._removeCloseLabel(issue, closeLabel);
+            if (this.options.startDate) {
+                const startDate = new Date(this.options.startDate);
+                const createdAt = new Date(issue.created_at);
+                issueLogger.info(`A start date was specified for the ${get_humanized_date_1.getHumanizedDate(startDate)} (${logger_service_1.LoggerService.cyan(this.options.startDate)})`);
+                // Expecting that GitHub will always set a creation date on the issues and PRs
+                // But you never know!
+                if (!is_valid_date_1.isValidDate(createdAt)) {
                     IssuesProcessor._endIssueProcessing(issue);
-                    continue; // Don't process closed issues
+                    core.setFailed(new Error(`Invalid issue field: "created_at". Expected a valid date`));
                 }
-                if (issue.locked) {
-                    issueLogger.info(`Skipping this $$type because it is locked`);
+                issueLogger.info(`$$type created the ${get_humanized_date_1.getHumanizedDate(createdAt)} (${logger_service_1.LoggerService.cyan(issue.created_at)})`);
+                if (!is_date_more_recent_than_1.isDateMoreRecentThan(createdAt, startDate)) {
+                    issueLogger.info(`Skipping this $$type because it was created before the specified start date`);
                     IssuesProcessor._endIssueProcessing(issue);
-                    continue; // Don't process locked issues
-                }
-                // Try to remove the close label when not close/locked issue or PR
-                yield this._removeCloseLabel(issue, closeLabel);
-                if (this.options.startDate) {
-                    const startDate = new Date(this.options.startDate);
-                    const createdAt = new Date(issue.created_at);
-                    issueLogger.info(`A start date was specified for the ${get_humanized_date_1.getHumanizedDate(startDate)} (${logger_service_1.LoggerService.cyan(this.options.startDate)})`);
-                    // Expecting that GitHub will always set a creation date on the issues and PRs
-                    // But you never know!
-                    if (!is_valid_date_1.isValidDate(createdAt)) {
-                        IssuesProcessor._endIssueProcessing(issue);
-                        core.setFailed(new Error(`Invalid issue field: "created_at". Expected a valid date`));
-                    }
-                    issueLogger.info(`$$type created the ${get_humanized_date_1.getHumanizedDate(createdAt)} (${logger_service_1.LoggerService.cyan(issue.created_at)})`);
-                    if (!is_date_more_recent_than_1.isDateMoreRecentThan(createdAt, startDate)) {
-                        issueLogger.info(`Skipping this $$type because it was created before the specified start date`);
-                        IssuesProcessor._endIssueProcessing(issue);
-                        continue; // Don't process issues which were created before the start date
-                    }
+                    return; // Don't process issues which were created before the start date
                 }
+            }
+            if (issue.isStale) {
+                issueLogger.info(`This $$type has a stale label`);
+            }
+            else {
+                issueLogger.info(`This $$type hasn't a stale label`);
+            }
+            const exemptLabels = words_to_list_1.wordsToList(issue.isPullRequest
+                ? this.options.exemptPrLabels
+                : this.options.exemptIssueLabels);
+            if (exemptLabels.some((exemptLabel) => is_labeled_1.isLabeled(issue, exemptLabel))) {
                 if (issue.isStale) {
-                    issueLogger.info(`This $$type has a stale label`);
-                }
-                else {
-                    issueLogger.info(`This $$type hasn't a stale label`);
+                    issueLogger.info(`An exempt label was added after the stale label.`);
+                    yield this._removeStaleLabel(issue, staleLabel);
                 }
-                const exemptLabels = words_to_list_1.wordsToList(issue.isPullRequest
-                    ? this.options.exemptPrLabels
-                    : this.options.exemptIssueLabels);
-                if (exemptLabels.some((exemptLabel) => is_labeled_1.isLabeled(issue, exemptLabel))) {
-                    if (issue.isStale) {
-                        issueLogger.info(`An exempt label was added after the stale label.`);
-                        yield this._removeStaleLabel(issue, staleLabel);
-                    }
-                    issueLogger.info(`Skipping this $$type because it has an exempt label`);
+                issueLogger.info(`Skipping this $$type because it has an exempt label`);
+                IssuesProcessor._endIssueProcessing(issue);
+                return; // Don't process exempt issues
+            }
+            const anyOfLabels = words_to_list_1.wordsToList(this._getAnyOfLabels(issue));
+            if (anyOfLabels.length > 0) {
+                issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.AnyOfLabels)} was specified to only process the issues and pull requests with one of those labels (${logger_service_1.LoggerService.cyan(anyOfLabels.length)})`);
+                const hasOneOfWhitelistedLabels = anyOfLabels.some((label) => {
+                    return is_labeled_1.isLabeled(issue, label);
+                });
+                if (!hasOneOfWhitelistedLabels) {
+                    issueLogger.info(logger_service_1.LoggerService.white('└──'), `Skipping this $$type because it doesn't have one of the required labels`);
                     IssuesProcessor._endIssueProcessing(issue);
-                    continue; // Don't process exempt issues
-                }
-                const anyOfLabels = words_to_list_1.wordsToList(this._getAnyOfLabels(issue));
-                if (anyOfLabels.length > 0) {
-                    issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.AnyOfLabels)} was specified to only process the issues and pull requests with one of those labels (${logger_service_1.LoggerService.cyan(anyOfLabels.length)})`);
-                    const hasOneOfWhitelistedLabels = anyOfLabels.some((label) => {
-                        return is_labeled_1.isLabeled(issue, label);
-                    });
-                    if (!hasOneOfWhitelistedLabels) {
-                        issueLogger.info(logger_service_1.LoggerService.white('└──'), `Skipping this $$type because it doesn't have one of the required labels`);
-                        IssuesProcessor._endIssueProcessing(issue);
-                        continue; // Don't process issues without any of the required labels
-                    }
-                    else {
-                        issueLogger.info(logger_service_1.LoggerService.white('├──'), `One of the required labels is present on this $$type`);
-                        issueLogger.info(logger_service_1.LoggerService.white('└──'), `Continuing the process for this $$type`);
-                    }
+                    return; // Don't process issues without any of the required labels
                 }
                 else {
-                    issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.AnyOfLabels)} was not specified`);
+                    issueLogger.info(logger_service_1.LoggerService.white('├──'), `One of the required labels is present on this $$type`);
                     issueLogger.info(logger_service_1.LoggerService.white('└──'), `Continuing the process for this $$type`);
                 }
-                const milestones = new milestones_1.Milestones(this.options, issue);
-                if (milestones.shouldExemptMilestones()) {
-                    IssuesProcessor._endIssueProcessing(issue);
-                    continue; // Don't process exempt milestones
-                }
-                const assignees = new assignees_1.Assignees(this.options, issue);
-                if (assignees.shouldExemptAssignees()) {
-                    IssuesProcessor._endIssueProcessing(issue);
-                    continue; // Don't process exempt assignees
-                }
-                // Should this issue be marked stale?
-                const shouldBeStale = !IssuesProcessor._updatedSince(issue.updated_at, daysBeforeStale);
-                // Determine if this issue needs to be marked stale first
-                if (!issue.isStale) {
-                    issueLogger.info(`This $$type is not stale`);
-                    const updatedAtDate = new Date(issue.updated_at);
-                    if (shouldBeStale) {
-                        issueLogger.info(`This $$type should be stale based on the last update date the ${get_humanized_date_1.getHumanizedDate(updatedAtDate)} (${logger_service_1.LoggerService.cyan(issue.updated_at)})`);
-                        if (shouldMarkAsStale) {
-                            issueLogger.info(`This $$type should be marked as stale based on the option ${issueLogger.createOptionLink(this._getDaysBeforeStaleUsedOptionName(issue))} (${logger_service_1.LoggerService.cyan(daysBeforeStale)})`);
-                            yield this._markStale(issue, staleMessage, staleLabel, skipMessage);
-                            issue.isStale = true; // This issue is now considered stale
-                            issueLogger.info(`This $$type is now stale`);
-                        }
-                        else {
-                            issueLogger.info(`This $$type should not be marked as stale based on the option ${issueLogger.createOptionLink(this._getDaysBeforeStaleUsedOptionName(issue))} (${logger_service_1.LoggerService.cyan(daysBeforeStale)})`);
-                        }
+            }
+            else {
+                issueLogger.info(`The option ${issueLogger.createOptionLink(option_1.Option.AnyOfLabels)} was not specified`);
+                issueLogger.info(logger_service_1.LoggerService.white('└──'), `Continuing the process for this $$type`);
+            }
+            const milestones = new milestones_1.Milestones(this.options, issue);
+            if (milestones.shouldExemptMilestones()) {
+                IssuesProcessor._endIssueProcessing(issue);
+                return; // Don't process exempt milestones
+            }
+            const assignees = new assignees_1.Assignees(this.options, issue);
+            if (assignees.shouldExemptAssignees()) {
+                IssuesProcessor._endIssueProcessing(issue);
+                return; // Don't process exempt assignees
+            }
+            // Should this issue be marked stale?
+            const shouldBeStale = !IssuesProcessor._updatedSince(issue.updated_at, daysBeforeStale);
+            // Determine if this issue needs to be marked stale first
+            if (!issue.isStale) {
+                issueLogger.info(`This $$type is not stale`);
+                const updatedAtDate = new Date(issue.updated_at);
+                if (shouldBeStale) {
+                    issueLogger.info(`This $$type should be stale based on the last update date the ${get_humanized_date_1.getHumanizedDate(updatedAtDate)} (${logger_service_1.LoggerService.cyan(issue.updated_at)})`);
+                    if (shouldMarkAsStale) {
+                        issueLogger.info(`This $$type should be marked as stale based on the option ${issueLogger.createOptionLink(this._getDaysBeforeStaleUsedOptionName(issue))} (${logger_service_1.LoggerService.cyan(daysBeforeStale)})`);
+                        yield this._markStale(issue, staleMessage, staleLabel, skipMessage);
+                        issue.isStale = true; // This issue is now considered stale
+                        issueLogger.info(`This $$type is now stale`);
                     }
                     else {
-                        issueLogger.info(`This $$type should not be stale based on the last update date the ${get_humanized_date_1.getHumanizedDate(updatedAtDate)} (${logger_service_1.LoggerService.cyan(issue.updated_at)})`);
+                        issueLogger.info(`This $$type should not be marked as stale based on the option ${issueLogger.createOptionLink(this._getDaysBeforeStaleUsedOptionName(issue))} (${logger_service_1.LoggerService.cyan(daysBeforeStale)})`);
                     }
                 }
-                // Process the issue if it was marked stale
-                if (issue.isStale) {
-                    issueLogger.info(`This $$type is already stale`);
-                    yield this._processStaleIssue(issue, staleLabel, actor, closeMessage, closeLabel);
+                else {
+                    issueLogger.info(`This $$type should not be stale based on the last update date the ${get_humanized_date_1.getHumanizedDate(updatedAtDate)} (${logger_service_1.LoggerService.cyan(issue.updated_at)})`);
                 }
-                IssuesProcessor._endIssueProcessing(issue);
             }
-            if (!this._operations.hasRemainingOperations()) {
-                this._logger.warning(logger_service_1.LoggerService.yellowBright(`No more operations left! Exiting...`));
-                this._logger.warning(`${logger_service_1.LoggerService.yellowBright('If you think that not enough issues were processed you could try to increase the quantity related to the')} ${this._logger.createOptionLink(option_1.Option.OperationsPerRun)} ${logger_service_1.LoggerService.yellowBright('option which is currently set to')} ${logger_service_1.LoggerService.cyan(this.options.operationsPerRun)}`);
-                return 0;
+            // Process the issue if it was marked stale
+            if (issue.isStale) {
+                issueLogger.info(`This $$type is already stale`);
+                yield this._processStaleIssue(issue, staleLabel, actor, labelsToAddWhenUnstale, labelsToRemoveWhenUnstale, closeMessage, closeLabel);
             }
-            this._logger.info(`${logger_service_1.LoggerService.green('Batch')} ${logger_service_1.LoggerService.cyan(`#${page}`)} ${logger_service_1.LoggerService.green('processed.')}`);
-            // Do the next batch
-            return this.processIssues(page + 1);
+            IssuesProcessor._endIssueProcessing(issue);
         });
     }
     // Grab comments for an issue since a given date
@@ -466,7 +483,7 @@ class IssuesProcessor {
         return __awaiter(this, void 0, void 0, function* () {
             // Find any comments since date on the given issue
             try {
-                this._operations.consumeOperation();
+                this.operations.consumeOperation();
                 (_a = this._statistics) === null || _a === void 0 ? void 0 : _a.incrementFetchedItemsCommentsCount();
                 const comments = yield this.client.issues.listComments({
                     owner: github_1.context.repo.owner,
@@ -487,7 +504,7 @@ class IssuesProcessor {
         return __awaiter(this, void 0, void 0, function* () {
             let actor;
             try {
-                this._operations.consumeOperation();
+                this.operations.consumeOperation();
                 actor = yield this.client.users.getAuthenticated();
             }
             catch (error) {
@@ -503,7 +520,7 @@ class IssuesProcessor {
             // generate type for response
             const endpoint = this.client.issues.listForRepo;
             try {
-                this._operations.consumeOperation();
+                this.operations.consumeOperation();
                 const issueResult = yield this.client.issues.listForRepo({
                     owner: github_1.context.repo.owner,
                     repo: github_1.context.repo.repo,
@@ -547,7 +564,7 @@ class IssuesProcessor {
         });
     }
     // handle all of the stale issue logic when we find a stale issue
-    _processStaleIssue(issue, staleLabel, actor, closeMessage, closeLabel) {
+    _processStaleIssue(issue, staleLabel, actor, labelsToAddWhenUnstale, labelsToRemoveWhenUnstale, closeMessage, closeLabel) {
         return __awaiter(this, void 0, void 0, function* () {
             const issueLogger = new issue_logger_1.IssueLogger(issue);
             const markedStaleOn = (yield this.getLabelCreationDate(issue, staleLabel)) || issue.updated_at;
@@ -563,18 +580,35 @@ class IssuesProcessor {
             const shouldRemoveStaleWhenUpdated = this._shouldRemoveStaleWhenUpdated(issue);
             issueLogger.info(`The option ${issueLogger.createOptionLink(this._getRemoveStaleWhenUpdatedUsedOptionName(issue))} is: ${logger_service_1.LoggerService.cyan(shouldRemoveStaleWhenUpdated)}`);
             if (shouldRemoveStaleWhenUpdated) {
-                issueLogger.info(`The stale label should not be removed`);
+                issueLogger.info(`The stale label should not be removed due to an update`);
+            }
+            else {
+                issueLogger.info(`The stale label should be removed if all conditions met`);
+            }
+            const shouldRemoveStaleWhenCommented = this._shouldRemoveStaleWhenCommented(issue);
+            issueLogger.info(`The option ${issueLogger.createOptionLink(this._getRemoveStaleWhenCommentedUsedOptionName(issue))} is: ${logger_service_1.LoggerService.cyan(shouldRemoveStaleWhenCommented)}`);
+            if (shouldRemoveStaleWhenCommented) {
+                issueLogger.info(`The stale label should not be removed due to a comment`);
             }
             else {
                 issueLogger.info(`The stale label should be removed if all conditions met`);
             }
             // Should we un-stale this issue?
-            if (shouldRemoveStaleWhenUpdated && issueHasComments) {
-                issueLogger.info(`Remove the stale label since the $$type has a comment and the workflow should remove the stale label when updated`);
+            if (shouldRemoveStaleWhenUpdated && issueHasUpdate) {
+                issueLogger.info(`Remove the stale label since the $$type has an update and the workflow should remove the stale label when updated`);
                 yield this._removeStaleLabel(issue, staleLabel);
                 issueLogger.info(`Skipping the process since the $$type is now un-stale`);
                 return; // Nothing to do because it is no longer stale
             }
+            else if (shouldRemoveStaleWhenCommented && issueHasComments) {
+                issueLogger.info(`Remove the stale label since the $$type has a comment and the workflow should remove the stale label when commented`);
+                yield this._removeStaleLabel(issue, staleLabel);
+                // Are there labels to remove or add when an issue is no longer stale?
+                yield this._removeLabelsWhenUnstale(issue, labelsToRemoveWhenUnstale);
+                yield this._addLabelsWhenUnstale(issue, labelsToAddWhenUnstale);
+                issueLogger.info(`Skipping the process since the $$type is now un-stale`);
+                return; // Nothing to do because it is no longer stale
+            }
             // Now start closing logic
             if (daysBeforeClose < 0) {
                 return; // Nothing to do because we aren't closing stale issues
@@ -641,12 +675,14 @@ class IssuesProcessor {
                 this._consumeIssueOperation(issue);
                 (_b = this._statistics) === null || _b === void 0 ? void 0 : _b.incrementAddedItemsLabel(issue);
                 (_c = this._statistics) === null || _c === void 0 ? void 0 : _c.incrementStaleItemsCount(issue);
-                yield this.client.issues.addLabels({
-                    owner: github_1.context.repo.owner,
-                    repo: github_1.context.repo.repo,
-                    issue_number: issue.number,
-                    labels: [staleLabel]
-                });
+                if (!this.options.debugOnly) {
+                    yield this.client.issues.addLabels({
+                        owner: github_1.context.repo.owner,
+                        repo: github_1.context.repo.repo,
+                        issue_number: issue.number,
+                        labels: [staleLabel]
+                    });
+                }
             }
             catch (error) {
                 issueLogger.error(`Error when adding a label: ${error.message}`);
@@ -681,12 +717,14 @@ class IssuesProcessor {
                 try {
                     this._consumeIssueOperation(issue);
                     (_b = this._statistics) === null || _b === void 0 ? void 0 : _b.incrementAddedItemsLabel(issue);
-                    yield this.client.issues.addLabels({
-                        owner: github_1.context.repo.owner,
-                        repo: github_1.context.repo.repo,
-                        issue_number: issue.number,
-                        labels: [closeLabel]
-                    });
+                    if (!this.options.debugOnly) {
+                        yield this.client.issues.addLabels({
+                            owner: github_1.context.repo.owner,
+                            repo: github_1.context.repo.repo,
+                            issue_number: issue.number,
+                            labels: [closeLabel]
+                        });
+                    }
                 }
                 catch (error) {
                     issueLogger.error(`Error when adding a label: ${error.message}`);
@@ -695,12 +733,14 @@ class IssuesProcessor {
             try {
                 this._consumeIssueOperation(issue);
                 (_c = this._statistics) === null || _c === void 0 ? void 0 : _c.incrementClosedItemsCount(issue);
-                yield this.client.issues.update({
-                    owner: github_1.context.repo.owner,
-                    repo: github_1.context.repo.repo,
-                    issue_number: issue.number,
-                    state: 'closed'
-                });
+                if (!this.options.debugOnly) {
+                    yield this.client.issues.update({
+                        owner: github_1.context.repo.owner,
+                        repo: github_1.context.repo.repo,
+                        issue_number: issue.number,
+                        state: 'closed'
+                    });
+                }
             }
             catch (error) {
                 issueLogger.error(`Error when updating this $$type: ${error.message}`);
@@ -714,14 +754,12 @@ class IssuesProcessor {
             try {
                 this._consumeIssueOperation(issue);
                 (_a = this._statistics) === null || _a === void 0 ? void 0 : _a.incrementFetchedPullRequestsCount();
-                if (!this.options.debugOnly) {
-                    const pullRequest = yield this.client.pulls.get({
-                        owner: github_1.context.repo.owner,
-                        repo: github_1.context.repo.repo,
-                        pull_number: issue.number
-                    });
-                    return pullRequest.data;
-                }
+                const pullRequest = yield this.client.pulls.get({
+                    owner: github_1.context.repo.owner,
+                    repo: github_1.context.repo.repo,
+                    pull_number: issue.number
+                });
+                return pullRequest.data;
             }
             catch (error) {
                 issueLogger.error(`Error when getting this $$type: ${error.message}`);
@@ -840,6 +878,56 @@ class IssuesProcessor {
         }
         return this.options.removeStaleWhenUpdated;
     }
+    _removeLabelsWhenUnstale(issue, removeLabels) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!removeLabels.length) {
+                return;
+            }
+            const issueLogger = new issue_logger_1.IssueLogger(issue);
+            issueLogger.info(`Removing all the labels specified via the ${this._logger.createOptionLink(option_1.Option.LabelsToRemoveWhenUnstale)} option.`);
+            for (const label of removeLabels.values()) {
+                yield this._removeLabel(issue, label);
+            }
+        });
+    }
+    _addLabelsWhenUnstale(issue, labelsToAdd) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!labelsToAdd.length) {
+                return;
+            }
+            const issueLogger = new issue_logger_1.IssueLogger(issue);
+            issueLogger.info(`Adding all the labels specified via the ${this._logger.createOptionLink(option_1.Option.LabelsToAddWhenUnstale)} option.`);
+            this.addedLabelIssues.push(issue);
+            try {
+                this.operations.consumeOperation();
+                (_a = this._statistics) === null || _a === void 0 ? void 0 : _a.incrementAddedItemsLabel(issue);
+                if (!this.options.debugOnly) {
+                    yield this.client.issues.addLabels({
+                        owner: github_1.context.repo.owner,
+                        repo: github_1.context.repo.repo,
+                        issue_number: issue.number,
+                        labels: labelsToAdd
+                    });
+                }
+            }
+            catch (error) {
+                this._logger.error(`Error when adding labels after updated from stale: ${error.message}`);
+            }
+        });
+    }
+    _shouldRemoveStaleWhenCommented(issue) {
+        if (issue.isPullRequest) {
+            if (is_boolean_1.isBoolean(this.options.removePrStaleWhenCommented)) {
+                return this.options.removePrStaleWhenCommented;
+            }
+            return this.options.removeStaleWhenCommented;
+        }
+        if (is_boolean_1.isBoolean(this.options.removeIssueStaleWhenCommented)) {
+            return this.options.removeIssueStaleWhenCommented;
+        }
+        return this.options.removeStaleWhenCommented;
+    }
     _removeStaleLabel(issue, staleLabel) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -871,7 +959,7 @@ class IssuesProcessor {
         });
     }
     _consumeIssueOperation(issue) {
-        this._operations.consumeOperation();
+        this.operations.consumeOperation();
         issue.operations.consumeOperation();
     }
     _getDaysBeforeStaleUsedOptionName(issue) {
@@ -901,6 +989,18 @@ class IssuesProcessor {
         }
         return option_1.Option.RemoveStaleWhenUpdated;
     }
+    _getRemoveStaleWhenCommentedUsedOptionName(issue) {
+        if (issue.isPullRequest) {
+            if (is_boolean_1.isBoolean(this.options.removePrStaleWhenCommented)) {
+                return option_1.Option.RemovePrStaleWhenCommented;
+            }
+            return option_1.Option.RemoveStaleWhenCommented;
+        }
+        if (is_boolean_1.isBoolean(this.options.removeIssueStaleWhenCommented)) {
+            return option_1.Option.RemoveIssueStaleWhenCommented;
+        }
+        return option_1.Option.RemoveStaleWhenCommented;
+    }
 }
 exports.IssuesProcessor = IssuesProcessor;
 
@@ -908,10 +1008,19 @@ exports.IssuesProcessor = IssuesProcessor;
 /***/ }),
 
 /***/ 2984:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.IssueLogger = void 0;
 const logger_1 = __nccwpck_require__(6212);
@@ -943,6 +1052,14 @@ class IssueLogger extends logger_1.Logger {
     error(...message) {
         super.error(this._format(...message));
     }
+    grouping(message, fn) {
+        const _super = Object.create(null, {
+            grouping: { get: () => super.grouping }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.grouping.call(this, this._format(message), fn);
+        });
+    }
     _replaceTokens(message) {
         return this._replaceTypeToken(message);
     }
@@ -1001,6 +1118,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -1019,6 +1145,11 @@ class Logger {
     error(...message) {
         core.error(logger_service_1.LoggerService.whiteBright(message.join(' ')));
     }
+    grouping(message, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return core.group(logger_service_1.LoggerService.whiteBright(message), fn);
+        });
+    }
     createLink(name, link) {
         return terminal_link_1.default(name, link);
     }
@@ -1283,8 +1414,8 @@ class Statistics {
         }
         return this._incrementUndoStaleIssuesCount(increment);
     }
-    setRemainingOperations(remainingOperations) {
-        this._operationsCount = remainingOperations;
+    setOperationsCount(operationsCount) {
+        this._operationsCount = operationsCount;
         return this;
     }
     incrementClosedItemsCount(issue, increment = 1) {
@@ -1630,6 +1761,9 @@ var Option;
     Option["RemoveStaleWhenUpdated"] = "remove-stale-when-updated";
     Option["RemoveIssueStaleWhenUpdated"] = "remove-issue-stale-when-updated";
     Option["RemovePrStaleWhenUpdated"] = "remove-pr-stale-when-updated";
+    Option["RemoveStaleWhenCommented"] = "remove-stale-when-commented";
+    Option["RemoveIssueStaleWhenCommented"] = "remove-issue-stale-when-commented";
+    Option["RemovePrStaleWhenCommented"] = "remove-pr-stale-when-commented";
     Option["DebugOnly"] = "debug-only";
     Option["Ascending"] = "ascending";
     Option["DeleteBranch"] = "delete-branch";
@@ -1647,6 +1781,8 @@ var Option;
     Option["ExemptAllIssueAssignees"] = "exempt-all-issue-assignees";
     Option["ExemptAllPrAssignees"] = "exempt-all-pr-assignees";
     Option["EnableStatistics"] = "enable-statistics";
+    Option["LabelsToRemoveWhenUnstale"] = "labels-to-remove-when-unstale";
+    Option["LabelsToAddWhenUnstale"] = "labels-to-add-when-unstale";
 })(Option = exports.Option || (exports.Option = {}));
 
 
@@ -1912,6 +2048,9 @@ function _getAndValidateArgs() {
         removeStaleWhenUpdated: !(core.getInput('remove-stale-when-updated') === 'false'),
         removeIssueStaleWhenUpdated: _toOptionalBoolean(core.getInput('remove-issue-stale-when-updated')),
         removePrStaleWhenUpdated: _toOptionalBoolean(core.getInput('remove-pr-stale-when-updated')),
+        removeStaleWhenCommented: !(core.getInput('remove-stale-when-commented') === 'false'),
+        removeIssueStaleWhenCommented: _toOptionalBoolean(core.getInput('remove-issue-stale-when-commented')),
+        removePrStaleWhenCommented: _toOptionalBoolean(core.getInput('remove-pr-stale-when-commented')),
         debugOnly: core.getInput('debug-only') === 'true',
         ascending: core.getInput('ascending') === 'true',
         deleteBranch: core.getInput('delete-branch') === 'true',
@@ -1930,7 +2069,9 @@ function _getAndValidateArgs() {
         exemptAllAssignees: core.getInput('exempt-all-assignees') === 'true',
         exemptAllIssueAssignees: _toOptionalBoolean('exempt-all-issue-assignees'),
         exemptAllPrAssignees: _toOptionalBoolean('exempt-all-pr-assignees'),
-        enableStatistics: core.getInput('enable-statistics') === 'true'
+        enableStatistics: core.getInput('enable-statistics') === 'true',
+        labelsToRemoveWhenUnstale: core.getInput('labels-to-remove-when-unstale'),
+        labelsToAddWhenUnstale: core.getInput('labels-to-add-when-unstale')
     };
     for (const numberInput of [
         'days-before-stale',
diff --git a/package-lock.json b/package-lock.json
index 9c4fc7a..2763820 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11069,9 +11069,9 @@
       }
     },
     "typescript": {
-      "version": "4.2.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.4.tgz",
-      "integrity": "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==",
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.2.tgz",
+      "integrity": "sha512-zZ4hShnmnoVnAHpVHWpTcxdv7dWP60S2FsydQLV8V5PbS3FifjWFFRiHSWpDJahly88PRyV5teTSLoq4eG7mKw==",
       "dev": true
     },
     "uglify-js": {
diff --git a/package.json b/package.json
index 7a93c0b..7585416 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,10 @@
     "node",
     "stale"
   ],
+  "engines": {
+    "node": "12",
+    "npm": "6"
+  },
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
@@ -58,6 +62,6 @@
     "standard-version": "^9.2.0",
     "terminal-link": "^2.1.1",
     "ts-jest": "^26.5.6",
-    "typescript": "^4.2.4"
+    "typescript": "^4.3.2"
   }
 }
diff --git a/src/classes/issue.spec.ts b/src/classes/issue.spec.ts
index 1fd8690..243709c 100644
--- a/src/classes/issue.spec.ts
+++ b/src/classes/issue.spec.ts
@@ -37,6 +37,9 @@ describe('Issue', (): void => {
       removeStaleWhenUpdated: false,
       removeIssueStaleWhenUpdated: undefined,
       removePrStaleWhenUpdated: undefined,
+      removeStaleWhenCommented: false,
+      removeIssueStaleWhenCommented: undefined,
+      removePrStaleWhenCommented: undefined,
       repoToken: '',
       staleIssueMessage: '',
       stalePrMessage: '',
@@ -55,7 +58,9 @@ describe('Issue', (): void => {
       exemptAllAssignees: false,
       exemptAllIssueAssignees: undefined,
       exemptAllPrAssignees: undefined,
-      enableStatistics: false
+      enableStatistics: false,
+      labelsToRemoveWhenUnstale: '',
+      labelsToAddWhenUnstale: ''
     };
     issueInterface = {
       title: 'dummy-title',
diff --git a/src/classes/issues-processor.ts b/src/classes/issues-processor.ts
index 72f5fcb..2509ff0 100644
--- a/src/classes/issues-processor.ts
+++ b/src/classes/issues-processor.ts
@@ -37,7 +37,8 @@ export class IssuesProcessor {
   }
 
   private static _endIssueProcessing(issue: Issue): void {
-    const consumedOperationsCount: number = issue.operations.getConsumedOperationsCount();
+    const consumedOperationsCount: number =
+      issue.operations.getConsumedOperationsCount();
 
     if (consumedOperationsCount > 0) {
       const issueLogger: IssueLogger = new IssueLogger(issue);
@@ -66,19 +67,20 @@ export class IssuesProcessor {
   }
 
   private readonly _logger: Logger = new Logger();
-  private readonly _operations: StaleOperations;
   private readonly _statistics: Statistics | undefined;
+  readonly operations: StaleOperations;
   readonly client: InstanceType<typeof GitHub>;
   readonly options: IIssuesProcessorOptions;
   readonly staleIssues: Issue[] = [];
   readonly closedIssues: Issue[] = [];
   readonly deletedBranchIssues: Issue[] = [];
   readonly removedLabelIssues: Issue[] = [];
+  readonly addedLabelIssues: Issue[] = [];
 
   constructor(options: IIssuesProcessorOptions) {
     this.options = options;
     this.client = getOctokit(this.options.repoToken);
-    this._operations = new StaleOperations(this.options);
+    this.operations = new StaleOperations(this.options);
 
     this._logger.info(
       LoggerService.yellow(`Starting the stale action process...`)
@@ -110,10 +112,10 @@ export class IssuesProcessor {
         LoggerService.green(`No more issues found to process. Exiting...`)
       );
       this._statistics
-        ?.setRemainingOperations(this._operations.getRemainingOperationsCount())
+        ?.setOperationsCount(this.operations.getConsumedOperationsCount())
         .logStats();
 
-      return this._operations.getRemainingOperationsCount();
+      return this.operations.getRemainingOperationsCount();
     } else {
       this._logger.info(
         `${LoggerService.yellow(
@@ -126,310 +128,342 @@ export class IssuesProcessor {
       );
     }
 
+    const labelsToAddWhenUnstale: string[] = wordsToList(
+      this.options.labelsToAddWhenUnstale
+    );
+    const labelsToRemoveWhenUnstale: string[] = wordsToList(
+      this.options.labelsToRemoveWhenUnstale
+    );
+
     for (const issue of issues.values()) {
+      // Stop the processing if no more operations remains
+      if (!this.operations.hasRemainingOperations()) {
+        break;
+      }
+
       const issueLogger: IssueLogger = new IssueLogger(issue);
-      this._statistics?.incrementProcessedItemsCount(issue);
+      await issueLogger.grouping(`$$type #${issue.number}`, async () => {
+        await this.processIssue(
+          issue,
+          actor,
+          labelsToAddWhenUnstale,
+          labelsToRemoveWhenUnstale
+        );
+      });
+    }
 
-      issueLogger.info(
-        `Found this $$type last updated at: ${LoggerService.cyan(
-          issue.updated_at
-        )}`
+    if (!this.operations.hasRemainingOperations()) {
+      this._logger.warning(
+        LoggerService.yellowBright(`No more operations left! Exiting...`)
       );
+      this._logger.warning(
+        `${LoggerService.yellowBright(
+          'If you think that not enough issues were processed you could try to increase the quantity related to the'
+        )} ${this._logger.createOptionLink(
+          Option.OperationsPerRun
+        )} ${LoggerService.yellowBright(
+          'option which is currently set to'
+        )} ${LoggerService.cyan(this.options.operationsPerRun)}`
+      );
+      this._statistics
+        ?.setOperationsCount(this.operations.getConsumedOperationsCount())
+        .logStats();
 
-      // calculate string based messages for this issue
-      const staleMessage: string = issue.isPullRequest
-        ? this.options.stalePrMessage
-        : this.options.staleIssueMessage;
-      const closeMessage: string = issue.isPullRequest
-        ? this.options.closePrMessage
-        : this.options.closeIssueMessage;
-      const staleLabel: string = issue.isPullRequest
-        ? this.options.stalePrLabel
-        : this.options.staleIssueLabel;
-      const closeLabel: string = issue.isPullRequest
-        ? this.options.closePrLabel
-        : this.options.closeIssueLabel;
-      const skipMessage = issue.isPullRequest
-        ? this.options.stalePrMessage.length === 0
-        : this.options.staleIssueMessage.length === 0;
-      const daysBeforeStale: number = issue.isPullRequest
-        ? this._getDaysBeforePrStale()
-        : this._getDaysBeforeIssueStale();
-      const onlyLabels: string[] = wordsToList(this._getOnlyLabels(issue));
-
-      if (onlyLabels.length > 0) {
-        issueLogger.info(
-          `The option ${issueLogger.createOptionLink(
-            Option.OnlyLabels
-          )} was specified to only process issues and pull requests with all those labels (${LoggerService.cyan(
-            onlyLabels.length
-          )})`
-        );
+      return 0;
+    }
 
-        const hasAllWhitelistedLabels: boolean = onlyLabels.every(
-          (label: Readonly<string>): boolean => {
-            return isLabeled(issue, label);
-          }
-        );
+    this._logger.info(
+      `${LoggerService.green('Batch')} ${LoggerService.cyan(
+        `#${page}`
+      )} ${LoggerService.green('processed.')}`
+    );
 
-        if (!hasAllWhitelistedLabels) {
-          issueLogger.info(
-            LoggerService.white('└──'),
-            `Skipping this $$type because it doesn't have all the required labels`
-          );
+    // Do the next batch
+    return this.processIssues(page + 1);
+  }
 
-          IssuesProcessor._endIssueProcessing(issue);
-          continue; // Don't process issues without all of the required labels
-        } else {
-          issueLogger.info(
-            LoggerService.white('├──'),
-            `All the required labels are present on this $$type`
-          );
-          issueLogger.info(
-            LoggerService.white('└──'),
-            `Continuing the process for this $$type`
-          );
+  async processIssue(
+    issue: Issue,
+    actor: string,
+    labelsToAddWhenUnstale: Readonly<string>[],
+    labelsToRemoveWhenUnstale: Readonly<string>[]
+  ): Promise<void> {
+    this._statistics?.incrementProcessedItemsCount(issue);
+
+    const issueLogger: IssueLogger = new IssueLogger(issue);
+    issueLogger.info(
+      `Found this $$type last updated at: ${LoggerService.cyan(
+        issue.updated_at
+      )}`
+    );
+
+    // calculate string based messages for this issue
+    const staleMessage: string = issue.isPullRequest
+      ? this.options.stalePrMessage
+      : this.options.staleIssueMessage;
+    const closeMessage: string = issue.isPullRequest
+      ? this.options.closePrMessage
+      : this.options.closeIssueMessage;
+    const staleLabel: string = issue.isPullRequest
+      ? this.options.stalePrLabel
+      : this.options.staleIssueLabel;
+    const closeLabel: string = issue.isPullRequest
+      ? this.options.closePrLabel
+      : this.options.closeIssueLabel;
+    const skipMessage = issue.isPullRequest
+      ? this.options.stalePrMessage.length === 0
+      : this.options.staleIssueMessage.length === 0;
+    const daysBeforeStale: number = issue.isPullRequest
+      ? this._getDaysBeforePrStale()
+      : this._getDaysBeforeIssueStale();
+    const onlyLabels: string[] = wordsToList(this._getOnlyLabels(issue));
+
+    if (onlyLabels.length > 0) {
+      issueLogger.info(
+        `The option ${issueLogger.createOptionLink(
+          Option.OnlyLabels
+        )} was specified to only process issues and pull requests with all those labels (${LoggerService.cyan(
+          onlyLabels.length
+        )})`
+      );
+
+      const hasAllWhitelistedLabels: boolean = onlyLabels.every(
+        (label: Readonly<string>): boolean => {
+          return isLabeled(issue, label);
         }
+      );
+
+      if (!hasAllWhitelistedLabels) {
+        issueLogger.info(
+          LoggerService.white('└──'),
+          `Skipping this $$type because it doesn't have all the required labels`
+        );
+
+        IssuesProcessor._endIssueProcessing(issue);
+        return; // Don't process issues without all of the required labels
       } else {
         issueLogger.info(
-          `The option ${issueLogger.createOptionLink(
-            Option.OnlyLabels
-          )} was not specified`
+          LoggerService.white('├──'),
+          `All the required labels are present on this $$type`
         );
         issueLogger.info(
           LoggerService.white('└──'),
           `Continuing the process for this $$type`
         );
       }
-
+    } else {
       issueLogger.info(
-        `Days before $$type stale: ${LoggerService.cyan(daysBeforeStale)}`
+        `The option ${issueLogger.createOptionLink(
+          Option.OnlyLabels
+        )} was not specified`
       );
+      issueLogger.info(
+        LoggerService.white('└──'),
+        `Continuing the process for this $$type`
+      );
+    }
 
-      const shouldMarkAsStale: boolean = shouldMarkWhenStale(daysBeforeStale);
+    issueLogger.info(
+      `Days before $$type stale: ${LoggerService.cyan(daysBeforeStale)}`
+    );
 
-      if (issue.state === 'closed') {
-        issueLogger.info(`Skipping this $$type because it is closed`);
-        IssuesProcessor._endIssueProcessing(issue);
-        continue; // Don't process closed issues
-      }
+    const shouldMarkAsStale: boolean = shouldMarkWhenStale(daysBeforeStale);
 
-      if (issue.locked) {
-        issueLogger.info(`Skipping this $$type because it is locked`);
-        IssuesProcessor._endIssueProcessing(issue);
-        continue; // Don't process locked issues
-      }
+    if (issue.state === 'closed') {
+      issueLogger.info(`Skipping this $$type because it is closed`);
+      IssuesProcessor._endIssueProcessing(issue);
+      return; // Don't process closed issues
+    }
 
-      // Try to remove the close label when not close/locked issue or PR
-      await this._removeCloseLabel(issue, closeLabel);
+    if (issue.locked) {
+      issueLogger.info(`Skipping this $$type because it is locked`);
+      IssuesProcessor._endIssueProcessing(issue);
+      return; // Don't process locked issues
+    }
 
-      if (this.options.startDate) {
-        const startDate: Date = new Date(this.options.startDate);
-        const createdAt: Date = new Date(issue.created_at);
+    // Try to remove the close label when not close/locked issue or PR
+    await this._removeCloseLabel(issue, closeLabel);
 
-        issueLogger.info(
-          `A start date was specified for the ${getHumanizedDate(
-            startDate
-          )} (${LoggerService.cyan(this.options.startDate)})`
+    if (this.options.startDate) {
+      const startDate: Date = new Date(this.options.startDate);
+      const createdAt: Date = new Date(issue.created_at);
+
+      issueLogger.info(
+        `A start date was specified for the ${getHumanizedDate(
+          startDate
+        )} (${LoggerService.cyan(this.options.startDate)})`
+      );
+
+      // Expecting that GitHub will always set a creation date on the issues and PRs
+      // But you never know!
+      if (!isValidDate(createdAt)) {
+        IssuesProcessor._endIssueProcessing(issue);
+        core.setFailed(
+          new Error(`Invalid issue field: "created_at". Expected a valid date`)
         );
+      }
 
-        // Expecting that GitHub will always set a creation date on the issues and PRs
-        // But you never know!
-        if (!isValidDate(createdAt)) {
-          IssuesProcessor._endIssueProcessing(issue);
-          core.setFailed(
-            new Error(
-              `Invalid issue field: "created_at". Expected a valid date`
-            )
-          );
-        }
+      issueLogger.info(
+        `$$type created the ${getHumanizedDate(
+          createdAt
+        )} (${LoggerService.cyan(issue.created_at)})`
+      );
 
+      if (!isDateMoreRecentThan(createdAt, startDate)) {
         issueLogger.info(
-          `$$type created the ${getHumanizedDate(
-            createdAt
-          )} (${LoggerService.cyan(issue.created_at)})`
+          `Skipping this $$type because it was created before the specified start date`
         );
 
-        if (!isDateMoreRecentThan(createdAt, startDate)) {
-          issueLogger.info(
-            `Skipping this $$type because it was created before the specified start date`
-          );
-
-          IssuesProcessor._endIssueProcessing(issue);
-          continue; // Don't process issues which were created before the start date
-        }
+        IssuesProcessor._endIssueProcessing(issue);
+        return; // Don't process issues which were created before the start date
       }
+    }
+
+    if (issue.isStale) {
+      issueLogger.info(`This $$type has a stale label`);
+    } else {
+      issueLogger.info(`This $$type hasn't a stale label`);
+    }
+
+    const exemptLabels: string[] = wordsToList(
+      issue.isPullRequest
+        ? this.options.exemptPrLabels
+        : this.options.exemptIssueLabels
+    );
 
+    if (
+      exemptLabels.some((exemptLabel: Readonly<string>): boolean =>
+        isLabeled(issue, exemptLabel)
+      )
+    ) {
       if (issue.isStale) {
-        issueLogger.info(`This $$type has a stale label`);
-      } else {
-        issueLogger.info(`This $$type hasn't a stale label`);
+        issueLogger.info(`An exempt label was added after the stale label.`);
+        await this._removeStaleLabel(issue, staleLabel);
       }
 
-      const exemptLabels: string[] = wordsToList(
-        issue.isPullRequest
-          ? this.options.exemptPrLabels
-          : this.options.exemptIssueLabels
-      );
+      issueLogger.info(`Skipping this $$type because it has an exempt label`);
+      IssuesProcessor._endIssueProcessing(issue);
+      return; // Don't process exempt issues
+    }
 
-      if (
-        exemptLabels.some((exemptLabel: Readonly<string>): boolean =>
-          isLabeled(issue, exemptLabel)
-        )
-      ) {
-        if (issue.isStale) {
-          issueLogger.info(`An exempt label was added after the stale label.`);
-          await this._removeStaleLabel(issue, staleLabel);
-        }
+    const anyOfLabels: string[] = wordsToList(this._getAnyOfLabels(issue));
 
-        issueLogger.info(`Skipping this $$type because it has an exempt label`);
-        IssuesProcessor._endIssueProcessing(issue);
-        continue; // Don't process exempt issues
-      }
+    if (anyOfLabels.length > 0) {
+      issueLogger.info(
+        `The option ${issueLogger.createOptionLink(
+          Option.AnyOfLabels
+        )} was specified to only process the issues and pull requests with one of those labels (${LoggerService.cyan(
+          anyOfLabels.length
+        )})`
+      );
 
-      const anyOfLabels: string[] = wordsToList(this._getAnyOfLabels(issue));
+      const hasOneOfWhitelistedLabels: boolean = anyOfLabels.some(
+        (label: Readonly<string>): boolean => {
+          return isLabeled(issue, label);
+        }
+      );
 
-      if (anyOfLabels.length > 0) {
+      if (!hasOneOfWhitelistedLabels) {
         issueLogger.info(
-          `The option ${issueLogger.createOptionLink(
-            Option.AnyOfLabels
-          )} was specified to only process the issues and pull requests with one of those labels (${LoggerService.cyan(
-            anyOfLabels.length
-          )})`
-        );
-
-        const hasOneOfWhitelistedLabels: boolean = anyOfLabels.some(
-          (label: Readonly<string>): boolean => {
-            return isLabeled(issue, label);
-          }
+          LoggerService.white('└──'),
+          `Skipping this $$type because it doesn't have one of the required labels`
         );
-
-        if (!hasOneOfWhitelistedLabels) {
-          issueLogger.info(
-            LoggerService.white('└──'),
-            `Skipping this $$type because it doesn't have one of the required labels`
-          );
-          IssuesProcessor._endIssueProcessing(issue);
-          continue; // Don't process issues without any of the required labels
-        } else {
-          issueLogger.info(
-            LoggerService.white('├──'),
-            `One of the required labels is present on this $$type`
-          );
-          issueLogger.info(
-            LoggerService.white('└──'),
-            `Continuing the process for this $$type`
-          );
-        }
+        IssuesProcessor._endIssueProcessing(issue);
+        return; // Don't process issues without any of the required labels
       } else {
         issueLogger.info(
-          `The option ${issueLogger.createOptionLink(
-            Option.AnyOfLabels
-          )} was not specified`
+          LoggerService.white('├──'),
+          `One of the required labels is present on this $$type`
         );
         issueLogger.info(
           LoggerService.white('└──'),
           `Continuing the process for this $$type`
         );
       }
+    } else {
+      issueLogger.info(
+        `The option ${issueLogger.createOptionLink(
+          Option.AnyOfLabels
+        )} was not specified`
+      );
+      issueLogger.info(
+        LoggerService.white('└──'),
+        `Continuing the process for this $$type`
+      );
+    }
 
-      const milestones: Milestones = new Milestones(this.options, issue);
+    const milestones: Milestones = new Milestones(this.options, issue);
 
-      if (milestones.shouldExemptMilestones()) {
-        IssuesProcessor._endIssueProcessing(issue);
-        continue; // Don't process exempt milestones
-      }
+    if (milestones.shouldExemptMilestones()) {
+      IssuesProcessor._endIssueProcessing(issue);
+      return; // Don't process exempt milestones
+    }
 
-      const assignees: Assignees = new Assignees(this.options, issue);
+    const assignees: Assignees = new Assignees(this.options, issue);
 
-      if (assignees.shouldExemptAssignees()) {
-        IssuesProcessor._endIssueProcessing(issue);
-        continue; // Don't process exempt assignees
-      }
+    if (assignees.shouldExemptAssignees()) {
+      IssuesProcessor._endIssueProcessing(issue);
+      return; // Don't process exempt assignees
+    }
 
-      // Should this issue be marked stale?
-      const shouldBeStale = !IssuesProcessor._updatedSince(
-        issue.updated_at,
-        daysBeforeStale
-      );
+    // Should this issue be marked stale?
+    const shouldBeStale = !IssuesProcessor._updatedSince(
+      issue.updated_at,
+      daysBeforeStale
+    );
 
-      // Determine if this issue needs to be marked stale first
-      if (!issue.isStale) {
-        issueLogger.info(`This $$type is not stale`);
-        const updatedAtDate: Date = new Date(issue.updated_at);
+    // Determine if this issue needs to be marked stale first
+    if (!issue.isStale) {
+      issueLogger.info(`This $$type is not stale`);
+      const updatedAtDate: Date = new Date(issue.updated_at);
 
-        if (shouldBeStale) {
+      if (shouldBeStale) {
+        issueLogger.info(
+          `This $$type should be stale based on the last update date the ${getHumanizedDate(
+            updatedAtDate
+          )} (${LoggerService.cyan(issue.updated_at)})`
+        );
+
+        if (shouldMarkAsStale) {
           issueLogger.info(
-            `This $$type should be stale based on the last update date the ${getHumanizedDate(
-              updatedAtDate
-            )} (${LoggerService.cyan(issue.updated_at)})`
+            `This $$type should be marked as stale based on the option ${issueLogger.createOptionLink(
+              this._getDaysBeforeStaleUsedOptionName(issue)
+            )} (${LoggerService.cyan(daysBeforeStale)})`
           );
-
-          if (shouldMarkAsStale) {
-            issueLogger.info(
-              `This $$type should be marked as stale based on the option ${issueLogger.createOptionLink(
-                this._getDaysBeforeStaleUsedOptionName(issue)
-              )} (${LoggerService.cyan(daysBeforeStale)})`
-            );
-            await this._markStale(issue, staleMessage, staleLabel, skipMessage);
-            issue.isStale = true; // This issue is now considered stale
-            issueLogger.info(`This $$type is now stale`);
-          } else {
-            issueLogger.info(
-              `This $$type should not be marked as stale based on the option ${issueLogger.createOptionLink(
-                this._getDaysBeforeStaleUsedOptionName(issue)
-              )} (${LoggerService.cyan(daysBeforeStale)})`
-            );
-          }
+          await this._markStale(issue, staleMessage, staleLabel, skipMessage);
+          issue.isStale = true; // This issue is now considered stale
+          issueLogger.info(`This $$type is now stale`);
         } else {
           issueLogger.info(
-            `This $$type should not be stale based on the last update date the ${getHumanizedDate(
-              updatedAtDate
-            )} (${LoggerService.cyan(issue.updated_at)})`
+            `This $$type should not be marked as stale based on the option ${issueLogger.createOptionLink(
+              this._getDaysBeforeStaleUsedOptionName(issue)
+            )} (${LoggerService.cyan(daysBeforeStale)})`
           );
         }
-      }
-
-      // Process the issue if it was marked stale
-      if (issue.isStale) {
-        issueLogger.info(`This $$type is already stale`);
-        await this._processStaleIssue(
-          issue,
-          staleLabel,
-          actor,
-          closeMessage,
-          closeLabel
+      } else {
+        issueLogger.info(
+          `This $$type should not be stale based on the last update date the ${getHumanizedDate(
+            updatedAtDate
+          )} (${LoggerService.cyan(issue.updated_at)})`
         );
       }
-
-      IssuesProcessor._endIssueProcessing(issue);
     }
 
-    if (!this._operations.hasRemainingOperations()) {
-      this._logger.warning(
-        LoggerService.yellowBright(`No more operations left! Exiting...`)
-      );
-      this._logger.warning(
-        `${LoggerService.yellowBright(
-          'If you think that not enough issues were processed you could try to increase the quantity related to the'
-        )} ${this._logger.createOptionLink(
-          Option.OperationsPerRun
-        )} ${LoggerService.yellowBright(
-          'option which is currently set to'
-        )} ${LoggerService.cyan(this.options.operationsPerRun)}`
+    // Process the issue if it was marked stale
+    if (issue.isStale) {
+      issueLogger.info(`This $$type is already stale`);
+      await this._processStaleIssue(
+        issue,
+        staleLabel,
+        actor,
+        labelsToAddWhenUnstale,
+        labelsToRemoveWhenUnstale,
+        closeMessage,
+        closeLabel
       );
-
-      return 0;
     }
 
-    this._logger.info(
-      `${LoggerService.green('Batch')} ${LoggerService.cyan(
-        `#${page}`
-      )} ${LoggerService.green('processed.')}`
-    );
-
-    // Do the next batch
-    return this.processIssues(page + 1);
+    IssuesProcessor._endIssueProcessing(issue);
   }
 
   // Grab comments for an issue since a given date
@@ -439,7 +473,7 @@ export class IssuesProcessor {
   ): Promise<IComment[]> {
     // Find any comments since date on the given issue
     try {
-      this._operations.consumeOperation();
+      this.operations.consumeOperation();
       this._statistics?.incrementFetchedItemsCommentsCount();
       const comments = await this.client.issues.listComments({
         owner: context.repo.owner,
@@ -459,7 +493,7 @@ export class IssuesProcessor {
     let actor;
 
     try {
-      this._operations.consumeOperation();
+      this.operations.consumeOperation();
       actor = await this.client.users.getAuthenticated();
     } catch (error) {
       return context.actor;
@@ -475,17 +509,16 @@ export class IssuesProcessor {
     type OctoKitIssueList = GetResponseTypeFromEndpointMethod<typeof endpoint>;
 
     try {
-      this._operations.consumeOperation();
-      const issueResult: OctoKitIssueList = await this.client.issues.listForRepo(
-        {
+      this.operations.consumeOperation();
+      const issueResult: OctoKitIssueList =
+        await this.client.issues.listForRepo({
           owner: context.repo.owner,
           repo: context.repo.repo,
           state: 'open',
           per_page: 100,
           direction: this.options.ascending ? 'asc' : 'desc',
           page
-        }
-      );
+        });
       this._statistics?.incrementFetchedItemsCount(issueResult.data.length);
 
       return issueResult.data.map(
@@ -536,6 +569,8 @@ export class IssuesProcessor {
     issue: Issue,
     staleLabel: string,
     actor: string,
+    labelsToAddWhenUnstale: Readonly<string>[],
+    labelsToRemoveWhenUnstale: Readonly<string>[],
     closeMessage?: string,
     closeLabel?: string
   ) {
@@ -571,9 +606,8 @@ export class IssuesProcessor {
       `$$type has been updated: ${LoggerService.cyan(issueHasUpdate)}`
     );
 
-    const shouldRemoveStaleWhenUpdated: boolean = this._shouldRemoveStaleWhenUpdated(
-      issue
-    );
+    const shouldRemoveStaleWhenUpdated: boolean =
+      this._shouldRemoveStaleWhenUpdated(issue);
 
     issueLogger.info(
       `The option ${issueLogger.createOptionLink(
@@ -582,7 +616,28 @@ export class IssuesProcessor {
     );
 
     if (shouldRemoveStaleWhenUpdated) {
-      issueLogger.info(`The stale label should not be removed`);
+      issueLogger.info(
+        `The stale label should not be removed due to an update`
+      );
+    } else {
+      issueLogger.info(
+        `The stale label should be removed if all conditions met`
+      );
+    }
+
+    const shouldRemoveStaleWhenCommented: boolean =
+      this._shouldRemoveStaleWhenCommented(issue);
+
+    issueLogger.info(
+      `The option ${issueLogger.createOptionLink(
+        this._getRemoveStaleWhenCommentedUsedOptionName(issue)
+      )} is: ${LoggerService.cyan(shouldRemoveStaleWhenCommented)}`
+    );
+
+    if (shouldRemoveStaleWhenCommented) {
+      issueLogger.info(
+        `The stale label should not be removed due to a comment`
+      );
     } else {
       issueLogger.info(
         `The stale label should be removed if all conditions met`
@@ -590,14 +645,27 @@ export class IssuesProcessor {
     }
 
     // Should we un-stale this issue?
-    if (shouldRemoveStaleWhenUpdated && issueHasComments) {
+    if (shouldRemoveStaleWhenUpdated && issueHasUpdate) {
       issueLogger.info(
-        `Remove the stale label since the $$type has a comment and the workflow should remove the stale label when updated`
+        `Remove the stale label since the $$type has an update and the workflow should remove the stale label when updated`
       );
       await this._removeStaleLabel(issue, staleLabel);
 
       issueLogger.info(`Skipping the process since the $$type is now un-stale`);
 
+      return; // Nothing to do because it is no longer stale
+    } else if (shouldRemoveStaleWhenCommented && issueHasComments) {
+      issueLogger.info(
+        `Remove the stale label since the $$type has a comment and the workflow should remove the stale label when commented`
+      );
+      await this._removeStaleLabel(issue, staleLabel);
+
+      // Are there labels to remove or add when an issue is no longer stale?
+      await this._removeLabelsWhenUnstale(issue, labelsToRemoveWhenUnstale);
+      await this._addLabelsWhenUnstale(issue, labelsToAddWhenUnstale);
+
+      issueLogger.info(`Skipping the process since the $$type is now un-stale`);
+
       return; // Nothing to do because it is no longer stale
     }
 
@@ -702,12 +770,15 @@ export class IssuesProcessor {
       this._consumeIssueOperation(issue);
       this._statistics?.incrementAddedItemsLabel(issue);
       this._statistics?.incrementStaleItemsCount(issue);
-      await this.client.issues.addLabels({
-        owner: context.repo.owner,
-        repo: context.repo.repo,
-        issue_number: issue.number,
-        labels: [staleLabel]
-      });
+
+      if (!this.options.debugOnly) {
+        await this.client.issues.addLabels({
+          owner: context.repo.owner,
+          repo: context.repo.repo,
+          issue_number: issue.number,
+          labels: [staleLabel]
+        });
+      }
     } catch (error) {
       issueLogger.error(`Error when adding a label: ${error.message}`);
     }
@@ -746,12 +817,15 @@ export class IssuesProcessor {
       try {
         this._consumeIssueOperation(issue);
         this._statistics?.incrementAddedItemsLabel(issue);
-        await this.client.issues.addLabels({
-          owner: context.repo.owner,
-          repo: context.repo.repo,
-          issue_number: issue.number,
-          labels: [closeLabel]
-        });
+
+        if (!this.options.debugOnly) {
+          await this.client.issues.addLabels({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            issue_number: issue.number,
+            labels: [closeLabel]
+          });
+        }
       } catch (error) {
         issueLogger.error(`Error when adding a label: ${error.message}`);
       }
@@ -760,12 +834,15 @@ export class IssuesProcessor {
     try {
       this._consumeIssueOperation(issue);
       this._statistics?.incrementClosedItemsCount(issue);
-      await this.client.issues.update({
-        owner: context.repo.owner,
-        repo: context.repo.repo,
-        issue_number: issue.number,
-        state: 'closed'
-      });
+
+      if (!this.options.debugOnly) {
+        await this.client.issues.update({
+          owner: context.repo.owner,
+          repo: context.repo.repo,
+          issue_number: issue.number,
+          state: 'closed'
+        });
+      }
     } catch (error) {
       issueLogger.error(`Error when updating this $$type: ${error.message}`);
     }
@@ -780,15 +857,13 @@ export class IssuesProcessor {
       this._consumeIssueOperation(issue);
       this._statistics?.incrementFetchedPullRequestsCount();
 
-      if (!this.options.debugOnly) {
-        const pullRequest = await this.client.pulls.get({
-          owner: context.repo.owner,
-          repo: context.repo.repo,
-          pull_number: issue.number
-        });
+      const pullRequest = await this.client.pulls.get({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        pull_number: issue.number
+      });
 
-        return pullRequest.data;
-      }
+      return pullRequest.data;
     } catch (error) {
       issueLogger.error(`Error when getting this $$type: ${error.message}`);
     }
@@ -944,6 +1019,79 @@ export class IssuesProcessor {
     return this.options.removeStaleWhenUpdated;
   }
 
+  private async _removeLabelsWhenUnstale(
+    issue: Issue,
+    removeLabels: Readonly<string>[]
+  ): Promise<void> {
+    if (!removeLabels.length) {
+      return;
+    }
+
+    const issueLogger: IssueLogger = new IssueLogger(issue);
+
+    issueLogger.info(
+      `Removing all the labels specified via the ${this._logger.createOptionLink(
+        Option.LabelsToRemoveWhenUnstale
+      )} option.`
+    );
+
+    for (const label of removeLabels.values()) {
+      await this._removeLabel(issue, label);
+    }
+  }
+
+  private async _addLabelsWhenUnstale(
+    issue: Issue,
+    labelsToAdd: Readonly<string>[]
+  ): Promise<void> {
+    if (!labelsToAdd.length) {
+      return;
+    }
+
+    const issueLogger: IssueLogger = new IssueLogger(issue);
+
+    issueLogger.info(
+      `Adding all the labels specified via the ${this._logger.createOptionLink(
+        Option.LabelsToAddWhenUnstale
+      )} option.`
+    );
+
+    this.addedLabelIssues.push(issue);
+
+    try {
+      this.operations.consumeOperation();
+      this._statistics?.incrementAddedItemsLabel(issue);
+      if (!this.options.debugOnly) {
+        await this.client.issues.addLabels({
+          owner: context.repo.owner,
+          repo: context.repo.repo,
+          issue_number: issue.number,
+          labels: labelsToAdd
+        });
+      }
+    } catch (error) {
+      this._logger.error(
+        `Error when adding labels after updated from stale: ${error.message}`
+      );
+    }
+  }
+
+  private _shouldRemoveStaleWhenCommented(issue: Issue): boolean {
+    if (issue.isPullRequest) {
+      if (isBoolean(this.options.removePrStaleWhenCommented)) {
+        return this.options.removePrStaleWhenCommented;
+      }
+
+      return this.options.removeStaleWhenCommented;
+    }
+
+    if (isBoolean(this.options.removeIssueStaleWhenCommented)) {
+      return this.options.removeIssueStaleWhenCommented;
+    }
+
+    return this.options.removeStaleWhenCommented;
+  }
+
   private async _removeStaleLabel(
     issue: Issue,
     staleLabel: Readonly<string>
@@ -1004,7 +1152,7 @@ export class IssuesProcessor {
   }
 
   private _consumeIssueOperation(issue: Readonly<Issue>): void {
-    this._operations.consumeOperation();
+    this.operations.consumeOperation();
     issue.operations.consumeOperation();
   }
 
@@ -1055,4 +1203,25 @@ export class IssuesProcessor {
 
     return Option.RemoveStaleWhenUpdated;
   }
+
+  private _getRemoveStaleWhenCommentedUsedOptionName(
+    issue: Readonly<Issue>
+  ):
+    | Option.RemovePrStaleWhenCommented
+    | Option.RemoveStaleWhenCommented
+    | Option.RemoveIssueStaleWhenCommented {
+    if (issue.isPullRequest) {
+      if (isBoolean(this.options.removePrStaleWhenCommented)) {
+        return Option.RemovePrStaleWhenCommented;
+      }
+
+      return Option.RemoveStaleWhenCommented;
+    }
+
+    if (isBoolean(this.options.removeIssueStaleWhenCommented)) {
+      return Option.RemoveIssueStaleWhenCommented;
+    }
+
+    return Option.RemoveStaleWhenCommented;
+  }
 }
diff --git a/src/classes/loggers/issue-logger.ts b/src/classes/loggers/issue-logger.ts
index 1dd6c79..7a58de2 100644
--- a/src/classes/loggers/issue-logger.ts
+++ b/src/classes/loggers/issue-logger.ts
@@ -35,6 +35,10 @@ export class IssueLogger extends Logger {
     super.error(this._format(...message));
   }
 
+  async grouping(message: string, fn: () => Promise<void>): Promise<void> {
+    return super.grouping(this._format(message), fn);
+  }
+
   private _replaceTokens(message: Readonly<string>): string {
     return this._replaceTypeToken(message);
   }
diff --git a/src/classes/loggers/logger.ts b/src/classes/loggers/logger.ts
index 4d10d76..3c8ed81 100644
--- a/src/classes/loggers/logger.ts
+++ b/src/classes/loggers/logger.ts
@@ -16,6 +16,10 @@ export class Logger {
     core.error(LoggerService.whiteBright(message.join(' ')));
   }
 
+  async grouping(message: string, fn: () => Promise<void>): Promise<void> {
+    return core.group(LoggerService.whiteBright(message), fn);
+  }
+
   createLink(name: Readonly<string>, link: Readonly<string>): string {
     return terminalLink(name, link);
   }
diff --git a/src/classes/milestones.ts b/src/classes/milestones.ts
index af804d5..db002ea 100644
--- a/src/classes/milestones.ts
+++ b/src/classes/milestones.ts
@@ -195,9 +195,8 @@ export class Milestones {
       return false;
     }
 
-    const cleanMilestone: CleanMilestone = Milestones._cleanMilestone(
-      milestone
-    );
+    const cleanMilestone: CleanMilestone =
+      Milestones._cleanMilestone(milestone);
 
     const isSameMilestone: boolean =
       cleanMilestone ===
diff --git a/src/classes/statistics.ts b/src/classes/statistics.ts
index 851e489..11f665c 100644
--- a/src/classes/statistics.ts
+++ b/src/classes/statistics.ts
@@ -65,8 +65,8 @@ export class Statistics {
     return this._incrementUndoStaleIssuesCount(increment);
   }
 
-  setRemainingOperations(remainingOperations: Readonly<number>): Statistics {
-    this._operationsCount = remainingOperations;
+  setOperationsCount(operationsCount: Readonly<number>): Statistics {
+    this._operationsCount = operationsCount;
 
     return this;
   }
diff --git a/src/enums/option.ts b/src/enums/option.ts
index 0ff794a..f50e720 100644
--- a/src/enums/option.ts
+++ b/src/enums/option.ts
@@ -24,6 +24,9 @@ export enum Option {
   RemoveStaleWhenUpdated = 'remove-stale-when-updated',
   RemoveIssueStaleWhenUpdated = 'remove-issue-stale-when-updated',
   RemovePrStaleWhenUpdated = 'remove-pr-stale-when-updated',
+  RemoveStaleWhenCommented = 'remove-stale-when-commented',
+  RemoveIssueStaleWhenCommented = 'remove-issue-stale-when-commented',
+  RemovePrStaleWhenCommented = 'remove-pr-stale-when-commented',
   DebugOnly = 'debug-only',
   Ascending = 'ascending',
   DeleteBranch = 'delete-branch',
@@ -40,5 +43,7 @@ export enum Option {
   ExemptAllAssignees = 'exempt-all-assignees',
   ExemptAllIssueAssignees = 'exempt-all-issue-assignees',
   ExemptAllPrAssignees = 'exempt-all-pr-assignees',
-  EnableStatistics = 'enable-statistics'
+  EnableStatistics = 'enable-statistics',
+  LabelsToRemoveWhenUnstale = 'labels-to-remove-when-unstale',
+  LabelsToAddWhenUnstale = 'labels-to-add-when-unstale'
 }
diff --git a/src/functions/is-labeled.spec.ts b/src/functions/is-labeled.spec.ts
index 249fcd0..30719f9 100644
--- a/src/functions/is-labeled.spec.ts
+++ b/src/functions/is-labeled.spec.ts
@@ -7,9 +7,9 @@ describe('isLabeled()', (): void => {
 
   describe('when the given issue contains no label', (): void => {
     beforeEach((): void => {
-      issue = ({
+      issue = {
         labels: []
-      } as unknown) as Issue;
+      } as unknown as Issue;
     });
 
     describe('when the given label is a simple label', (): void => {
diff --git a/src/interfaces/issues-processor-options.ts b/src/interfaces/issues-processor-options.ts
index 6ce79db..1f29ab8 100644
--- a/src/interfaces/issues-processor-options.ts
+++ b/src/interfaces/issues-processor-options.ts
@@ -28,6 +28,9 @@ export interface IIssuesProcessorOptions {
   removeStaleWhenUpdated: boolean;
   removeIssueStaleWhenUpdated: boolean | undefined;
   removePrStaleWhenUpdated: boolean | undefined;
+  removeStaleWhenCommented: boolean;
+  removeIssueStaleWhenCommented: boolean | undefined;
+  removePrStaleWhenCommented: boolean | undefined;
   debugOnly: boolean;
   ascending: boolean;
   deleteBranch: boolean;
@@ -45,4 +48,6 @@ export interface IIssuesProcessorOptions {
   exemptAllIssueAssignees: boolean | undefined;
   exemptAllPrAssignees: boolean | undefined;
   enableStatistics: boolean;
+  labelsToRemoveWhenUnstale: string;
+  labelsToAddWhenUnstale: string;
 }
diff --git a/src/main.ts b/src/main.ts
index 98e6674..b38a5bb 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -62,6 +62,15 @@ function _getAndValidateArgs(): IIssuesProcessorOptions {
     removePrStaleWhenUpdated: _toOptionalBoolean(
       core.getInput('remove-pr-stale-when-updated')
     ),
+    removeStaleWhenCommented: !(
+      core.getInput('remove-stale-when-commented') === 'false'
+    ),
+    removeIssueStaleWhenCommented: _toOptionalBoolean(
+      core.getInput('remove-issue-stale-when-commented')
+    ),
+    removePrStaleWhenCommented: _toOptionalBoolean(
+      core.getInput('remove-pr-stale-when-commented')
+    ),
     debugOnly: core.getInput('debug-only') === 'true',
     ascending: core.getInput('ascending') === 'true',
     deleteBranch: core.getInput('delete-branch') === 'true',
@@ -81,7 +90,9 @@ function _getAndValidateArgs(): IIssuesProcessorOptions {
     exemptAllAssignees: core.getInput('exempt-all-assignees') === 'true',
     exemptAllIssueAssignees: _toOptionalBoolean('exempt-all-issue-assignees'),
     exemptAllPrAssignees: _toOptionalBoolean('exempt-all-pr-assignees'),
-    enableStatistics: core.getInput('enable-statistics') === 'true'
+    enableStatistics: core.getInput('enable-statistics') === 'true',
+    labelsToRemoveWhenUnstale: core.getInput('labels-to-remove-when-unstale'),
+    labelsToAddWhenUnstale: core.getInput('labels-to-add-when-unstale')
   };
 
   for (const numberInput of [


Test patch:
diff --git a/__tests__/any-of-labels.spec.ts b/__tests__/any-of-labels.spec.ts
index cfed44b..6aa1560 100644
--- a/__tests__/any-of-labels.spec.ts
+++ b/__tests__/any-of-labels.spec.ts
@@ -1112,14 +1112,12 @@ class IssuesProcessorBuilder {
 
   issues(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issuesOrPrs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            pull_request: null
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: null
+        };
+      })
     );
 
     return this;
@@ -1127,14 +1125,12 @@ class IssuesProcessorBuilder {
 
   prs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issuesOrPrs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            pull_request: {key: 'value'}
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: {key: 'value'}
+        };
+      })
     );
 
     return this;
diff --git a/__tests__/constants/default-processor-options.ts b/__tests__/constants/default-processor-options.ts
index a0550f4..ac86484 100644
--- a/__tests__/constants/default-processor-options.ts
+++ b/__tests__/constants/default-processor-options.ts
@@ -29,6 +29,9 @@ export const DefaultProcessorOptions: IIssuesProcessorOptions = Object.freeze({
   removeStaleWhenUpdated: false,
   removeIssueStaleWhenUpdated: undefined,
   removePrStaleWhenUpdated: undefined,
+  removeStaleWhenCommented: false,
+  removeIssueStaleWhenCommented: undefined,
+  removePrStaleWhenCommented: undefined,
   ascending: false,
   deleteBranch: false,
   startDate: '',
@@ -44,5 +47,7 @@ export const DefaultProcessorOptions: IIssuesProcessorOptions = Object.freeze({
   exemptAllAssignees: false,
   exemptAllIssueAssignees: undefined,
   exemptAllPrAssignees: undefined,
-  enableStatistics: true
+  enableStatistics: true,
+  labelsToRemoveWhenUnstale: '',
+  labelsToAddWhenUnstale: ''
 });
diff --git a/__tests__/functions/generate-issue.ts b/__tests__/functions/generate-issue.ts
index 3b3fe43..6817d8e 100644
--- a/__tests__/functions/generate-issue.ts
+++ b/__tests__/functions/generate-issue.ts
@@ -32,12 +32,10 @@ export function generateIssue(
           title: milestone
         }
       : undefined,
-    assignees: assignees.map(
-      (assignee: Readonly<string>): IAssignee => {
-        return {
-          login: assignee
-        };
-      }
-    )
+    assignees: assignees.map((assignee: Readonly<string>): IAssignee => {
+      return {
+        login: assignee
+      };
+    })
   });
 }
diff --git a/__tests__/main.spec.ts b/__tests__/main.spec.ts
index 1c56531..da33571 100644
--- a/__tests__/main.spec.ts
+++ b/__tests__/main.spec.ts
@@ -1220,7 +1220,7 @@ test('stale issues should not be closed if days is set to -1', async () => {
 });
 
 test('stale label should be removed if a comment was added to a stale issue', async () => {
-  const opts = {...DefaultProcessorOptions, removeStaleWhenUpdated: true};
+  const opts = {...DefaultProcessorOptions, removeStaleWhenCommented: true};
   const TestIssueList: Issue[] = [
     generateIssue(
       opts,
@@ -1255,8 +1255,81 @@ test('stale label should be removed if a comment was added to a stale issue', as
   expect(processor.removedLabelIssues).toHaveLength(1);
 });
 
-test('stale label should not be removed if a comment was added by the bot (and the issue should be closed)', async () => {
+test('when the option "labelsToAddWhenUnstale" is set, the labels should be added when unstale', async () => {
+  expect.assertions(4);
+  const opts = {
+    ...DefaultProcessorOptions,
+    removeStaleWhenCommented: true,
+    labelsToAddWhenUnstale: 'test'
+  };
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      opts,
+      1,
+      'An issue that should have labels added to it when unstale',
+      '2020-01-01T17:00:00Z',
+      '2020-01-01T17:00:00Z',
+      false,
+      ['Stale']
+    )
+  ];
+  const processor = new IssuesProcessorMock(
+    opts,
+    async () => 'abot',
+    async p => (p === 1 ? TestIssueList : []),
+    async () => [
+      {
+        user: {
+          login: 'notme',
+          type: 'User'
+        }
+      }
+    ], // return a fake comment to indicate there was an update
+    async () => new Date().toDateString()
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues).toHaveLength(0);
+  expect(processor.staleIssues).toHaveLength(0);
+  // Stale should have been removed
+  expect(processor.removedLabelIssues).toHaveLength(1);
+  // Some label should have been added
+  expect(processor.addedLabelIssues).toHaveLength(1);
+});
+
+test('stale label should be removed if a stale issue was updated', async () => {
   const opts = {...DefaultProcessorOptions, removeStaleWhenUpdated: true};
+  const TestIssueList: Issue[] = [
+    generateIssue(
+      opts,
+      1,
+      'An issue that should un-stale',
+      new Date().toDateString(),
+      '2020-01-01T17:00:00Z',
+      false,
+      ['Stale']
+    )
+  ];
+  const processor = new IssuesProcessorMock(
+    opts,
+    async () => 'abot',
+    async p => (p === 1 ? TestIssueList : []),
+    async () => [],
+    async () => '2020-01-02T17:00:00Z'
+  );
+
+  // process our fake issue list
+  await processor.processIssues(1);
+
+  expect(processor.closedIssues).toHaveLength(0);
+  expect(processor.staleIssues).toHaveLength(0);
+  expect(processor.removedLabelIssues).toHaveLength(1);
+});
+
+test('stale label should not be removed if a comment was added by the bot (and the issue should be closed)', async () => {
+  const opts = {...DefaultProcessorOptions, removeStaleWhenCommented: true};
   github.context.actor = 'abot';
   const TestIssueList: Issue[] = [
     generateIssue(
@@ -1295,7 +1368,7 @@ test('stale label should not be removed if a comment was added by the bot (and t
 test('stale label containing a space should be removed if a comment was added to a stale issue', async () => {
   const opts: IIssuesProcessorOptions = {
     ...DefaultProcessorOptions,
-    removeStaleWhenUpdated: true,
+    removeStaleWhenCommented: true,
     staleIssueLabel: 'stat: stale'
   };
   const TestIssueList: Issue[] = [
@@ -2234,7 +2307,7 @@ test('processing an issue stale since less than the daysBeforeStale with a stale
     daysBeforeStale: 30,
     daysBeforeClose: 7,
     closeIssueMessage: 'close message',
-    removeStaleWhenUpdated: false
+    removeStaleWhenCommented: false
   };
   const now: Date = new Date();
   const updatedAt: Date = new Date(now.setDate(now.getDate() - 9));
@@ -2276,7 +2349,7 @@ test('processing an issue stale since less than the daysBeforeStale without a st
     daysBeforeStale: 30,
     daysBeforeClose: 7,
     closeIssueMessage: 'close message',
-    removeStaleWhenUpdated: false
+    removeStaleWhenCommented: false
   };
   const now: Date = new Date();
   const updatedAt: Date = new Date(now.setDate(now.getDate() - 9));
diff --git a/__tests__/only-labels.spec.ts b/__tests__/only-labels.spec.ts
index d8ceddc..042642b 100644
--- a/__tests__/only-labels.spec.ts
+++ b/__tests__/only-labels.spec.ts
@@ -1112,14 +1112,12 @@ class IssuesProcessorBuilder {
 
   issues(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issuesOrPrs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            pull_request: null
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: null
+        };
+      })
     );
 
     return this;
@@ -1127,14 +1125,12 @@ class IssuesProcessorBuilder {
 
   prs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issuesOrPrs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            pull_request: {key: 'value'}
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: {key: 'value'}
+        };
+      })
     );
 
     return this;
diff --git a/__tests__/operations-per-run.spec.ts b/__tests__/operations-per-run.spec.ts
new file mode 100644
index 0000000..e73593c
--- /dev/null
+++ b/__tests__/operations-per-run.spec.ts
@@ -0,0 +1,228 @@
+import {Issue} from '../src/classes/issue';
+import {IIssuesProcessorOptions} from '../src/interfaces/issues-processor-options';
+import {IsoDateString} from '../src/types/iso-date-string';
+import {IssuesProcessorMock} from './classes/issues-processor-mock';
+import {DefaultProcessorOptions} from './constants/default-processor-options';
+import {generateIssue} from './functions/generate-issue';
+
+describe('operations per run option', (): void => {
+  let sut: SUT;
+
+  beforeEach((): void => {
+    sut = new SUT();
+  });
+
+  describe('when one issue should be stale within 10 days and updated 20 days ago', (): void => {
+    beforeEach((): void => {
+      sut.staleIn(10).newIssue().updated(20);
+    });
+
+    describe('when the operations per run option is set to 1', (): void => {
+      beforeEach((): void => {
+        sut.operationsPerRun(1);
+      });
+
+      it('should consume 1 operation (stale label)', async () => {
+        expect.assertions(2);
+
+        await sut.test();
+
+        expect(sut.processor.staleIssues).toHaveLength(1);
+        expect(
+          sut.processor.operations.getConsumedOperationsCount()
+        ).toStrictEqual(1);
+      });
+    });
+  });
+
+  describe('when one issue should be stale within 10 days and updated 20 days ago and a comment should be added when stale', (): void => {
+    beforeEach((): void => {
+      sut.staleIn(10).commentOnStale().newIssue().updated(20);
+    });
+
+    describe('when the operations per run option is set to 2', (): void => {
+      beforeEach((): void => {
+        sut.operationsPerRun(2);
+      });
+
+      it('should consume 2 operations (stale label, comment)', async () => {
+        expect.assertions(2);
+
+        await sut.test();
+
+        expect(sut.processor.staleIssues).toHaveLength(1);
+        expect(
+          sut.processor.operations.getConsumedOperationsCount()
+        ).toStrictEqual(2);
+      });
+    });
+
+    // Special case were we continue the issue processing even if the operations per run is reached
+    describe('when the operations per run option is set to 1', (): void => {
+      beforeEach((): void => {
+        sut.operationsPerRun(1);
+      });
+
+      it('should consume 2 operations (stale label, comment)', async () => {
+        expect.assertions(2);
+
+        await sut.test();
+
+        expect(sut.processor.staleIssues).toHaveLength(1);
+        expect(
+          sut.processor.operations.getConsumedOperationsCount()
+        ).toStrictEqual(2);
+      });
+    });
+  });
+
+  describe('when two issues should be stale within 10 days and updated 20 days ago and a comment should be added when stale', (): void => {
+    beforeEach((): void => {
+      sut.staleIn(10).commentOnStale();
+      sut.newIssue().updated(20);
+      sut.newIssue().updated(20);
+    });
+
+    describe('when the operations per run option is set to 3', (): void => {
+      beforeEach((): void => {
+        sut.operationsPerRun(3);
+      });
+
+      it('should consume 4 operations (stale label, comment)', async () => {
+        expect.assertions(2);
+
+        await sut.test();
+
+        expect(sut.processor.staleIssues).toHaveLength(2);
+        expect(
+          sut.processor.operations.getConsumedOperationsCount()
+        ).toStrictEqual(4);
+      });
+    });
+
+    describe('when the operations per run option is set to 2', (): void => {
+      beforeEach((): void => {
+        sut.operationsPerRun(2);
+      });
+
+      it('should consume 2 operations (stale label, comment) and stop', async () => {
+        expect.assertions(2);
+
+        await sut.test();
+
+        expect(sut.processor.staleIssues).toHaveLength(1);
+        expect(
+          sut.processor.operations.getConsumedOperationsCount()
+        ).toStrictEqual(2);
+      });
+    });
+
+    // Special case were we continue the issue processing even if the operations per run is reached
+    describe('when the operations per run option is set to 1', (): void => {
+      beforeEach((): void => {
+        sut.operationsPerRun(1);
+      });
+
+      it('should consume 2 operations (stale label, comment) and stop', async () => {
+        expect.assertions(2);
+
+        await sut.test();
+
+        expect(sut.processor.staleIssues).toHaveLength(1);
+        expect(
+          sut.processor.operations.getConsumedOperationsCount()
+        ).toStrictEqual(2);
+      });
+    });
+  });
+});
+
+class SUT {
+  processor!: IssuesProcessorMock;
+  private _opts: IIssuesProcessorOptions = {
+    ...DefaultProcessorOptions,
+    staleIssueMessage: ''
+  };
+  private _testIssueList: Issue[] = [];
+  private _sutIssues: SUTIssue[] = [];
+
+  newIssue(): SUTIssue {
+    const sutIssue: SUTIssue = new SUTIssue();
+    this._sutIssues.push(sutIssue);
+
+    return sutIssue;
+  }
+
+  staleIn(days: number): SUT {
+    this._updateOptions({
+      daysBeforeIssueStale: days
+    });
+
+    return this;
+  }
+
+  commentOnStale(): SUT {
+    this._updateOptions({
+      staleIssueMessage: 'Dummy stale issue message'
+    });
+
+    return this;
+  }
+
+  operationsPerRun(count: number): SUT {
+    this._updateOptions({
+      operationsPerRun: count
+    });
+
+    return this;
+  }
+
+  async test(): Promise<number> {
+    return this._setTestIssueList()._setProcessor();
+  }
+
+  private _updateOptions(opts: Partial<IIssuesProcessorOptions>): SUT {
+    this._opts = {...this._opts, ...opts};
+
+    return this;
+  }
+
+  private _setTestIssueList(): SUT {
+    this._testIssueList = this._sutIssues.map((sutIssue: SUTIssue): Issue => {
+      return generateIssue(
+        this._opts,
+        1,
+        'My first issue',
+        sutIssue.updatedAt,
+        sutIssue.updatedAt,
+        false
+      );
+    });
+
+    return this;
+  }
+
+  private async _setProcessor(): Promise<number> {
+    this.processor = new IssuesProcessorMock(
+      this._opts,
+      async () => 'abot',
+      async p => (p === 1 ? this._testIssueList : []),
+      async () => [],
+      async () => new Date().toDateString()
+    );
+
+    return this.processor.processIssues(1);
+  }
+}
+
+class SUTIssue {
+  updatedAt: IsoDateString = '2020-01-01T17:00:00Z';
+
+  updated(daysAgo: number): SUTIssue {
+    const today = new Date();
+    today.setDate(today.getDate() - daysAgo);
+    this.updatedAt = today.toISOString();
+
+    return this;
+  }
+}
diff --git a/__tests__/remove-stale-when-commented.spec.ts b/__tests__/remove-stale-when-commented.spec.ts
new file mode 100644
index 0000000..531223d
--- /dev/null
+++ b/__tests__/remove-stale-when-commented.spec.ts
@@ -0,0 +1,556 @@
+import {Issue} from '../src/classes/issue';
+import {IIssue} from '../src/interfaces/issue';
+import {IIssuesProcessorOptions} from '../src/interfaces/issues-processor-options';
+import {ILabel} from '../src/interfaces/label';
+import {IssuesProcessorMock} from './classes/issues-processor-mock';
+import {DefaultProcessorOptions} from './constants/default-processor-options';
+import {generateIssue} from './functions/generate-issue';
+
+let issuesProcessorBuilder: IssuesProcessorBuilder;
+let issuesProcessor: IssuesProcessorMock;
+
+/**
+ * @description
+ * Assuming there is a comment on the issue
+ */
+describe('remove-stale-when-commented option', (): void => {
+  beforeEach((): void => {
+    issuesProcessorBuilder = new IssuesProcessorBuilder();
+  });
+
+  describe('when the option "remove-stale-when-commented" is disabled', (): void => {
+    beforeEach((): void => {
+      issuesProcessorBuilder.keepStaleWhenCommented();
+    });
+
+    test('should not remove the stale label on the issue', async (): Promise<void> => {
+      expect.assertions(1);
+      issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+      await issuesProcessor.processIssues();
+
+      expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+    });
+
+    test('should not remove the stale label on the pull request', async (): Promise<void> => {
+      expect.assertions(1);
+      issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+      await issuesProcessor.processIssues();
+
+      expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+    });
+  });
+
+  describe('when the option "remove-stale-when-commented" is enabled', (): void => {
+    beforeEach((): void => {
+      issuesProcessorBuilder.removeStaleWhenCommented();
+    });
+
+    test('should remove the stale label on the issue', async (): Promise<void> => {
+      expect.assertions(1);
+      issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+      await issuesProcessor.processIssues();
+
+      expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+    });
+
+    test('should remove the stale label on the pull request', async (): Promise<void> => {
+      expect.assertions(1);
+      issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+      await issuesProcessor.processIssues();
+
+      expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+    });
+  });
+});
+
+describe('remove-issue-stale-when-commented option', (): void => {
+  beforeEach((): void => {
+    issuesProcessorBuilder = new IssuesProcessorBuilder();
+  });
+
+  describe('when the option "remove-stale-when-commented" is disabled', (): void => {
+    beforeEach((): void => {
+      issuesProcessorBuilder.keepStaleWhenCommented();
+    });
+
+    describe('when the option "remove-issue-stale-when-commented" is unset', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.unsetIssueStaleWhenCommented();
+      });
+
+      test('should not remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+
+      test('should not remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+    });
+
+    describe('when the option "remove-issue-stale-when-commented" is disabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.keepIssueStaleWhenCommented();
+      });
+
+      test('should not remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+
+      test('should not remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+    });
+
+    describe('when the option "remove-issue-stale-when-commented" is enabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.removeIssueStaleWhenCommented();
+      });
+
+      test('should remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+
+      test('should not remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+    });
+  });
+
+  describe('when the option "remove-stale-when-commented" is enabled', (): void => {
+    beforeEach((): void => {
+      issuesProcessorBuilder.removeStaleWhenCommented();
+    });
+
+    describe('when the option "remove-issue-stale-when-commented" is unset', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.unsetIssueStaleWhenCommented();
+      });
+
+      test('should remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+
+      test('should remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+    });
+
+    describe('when the option "remove-issue-stale-when-commented" is disabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.keepIssueStaleWhenCommented();
+      });
+
+      test('should not remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+
+      test('should remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+    });
+
+    describe('when the option "remove-issue-stale-when-commented" is enabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.removeIssueStaleWhenCommented();
+      });
+
+      test('should remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+
+      test('should remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+    });
+  });
+});
+
+describe('remove-pr-stale-when-commented option', (): void => {
+  beforeEach((): void => {
+    issuesProcessorBuilder = new IssuesProcessorBuilder();
+  });
+
+  describe('when the option "remove-stale-when-commented" is disabled', (): void => {
+    beforeEach((): void => {
+      issuesProcessorBuilder.keepStaleWhenCommented();
+    });
+
+    describe('when the option "remove-pr-stale-when-commented" is unset', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.unsetPrStaleWhenCommented();
+      });
+
+      test('should not remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+
+      test('should not remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+    });
+
+    describe('when the option "remove-pr-stale-when-commented" is disabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.keepPrStaleWhenCommented();
+      });
+
+      test('should not remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+
+      test('should not remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+    });
+
+    describe('when the option "remove-pr-stale-when-commented" is enabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.removePrStaleWhenCommented();
+      });
+
+      test('should not remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+
+      test('should remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+    });
+  });
+
+  describe('when the option "remove-stale-when-commented" is enabled', (): void => {
+    beforeEach((): void => {
+      issuesProcessorBuilder.removeStaleWhenCommented();
+    });
+
+    describe('when the option "remove-pr-stale-when-commented" is unset', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.unsetPrStaleWhenCommented();
+      });
+
+      test('should remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+
+      test('should remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+    });
+
+    describe('when the option "remove-pr-stale-when-commented" is disabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.keepPrStaleWhenCommented();
+      });
+
+      test('should remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+
+      test('should not remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(0);
+      });
+    });
+
+    describe('when the option "remove-pr-stale-when-commented" is enabled', (): void => {
+      beforeEach((): void => {
+        issuesProcessorBuilder.removePrStaleWhenCommented();
+      });
+
+      test('should remove the stale label on the issue', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.staleIssues([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+
+      test('should remove the stale label on the pull request', async (): Promise<void> => {
+        expect.assertions(1);
+        issuesProcessor = issuesProcessorBuilder.stalePrs([{}]).build();
+
+        await issuesProcessor.processIssues();
+
+        expect(issuesProcessor.removedLabelIssues).toHaveLength(1);
+      });
+    });
+  });
+});
+
+class IssuesProcessorBuilder {
+  private _options: IIssuesProcessorOptions = {
+    ...DefaultProcessorOptions
+  };
+  private _issues: Issue[] = [];
+
+  keepStaleWhenCommented(): IssuesProcessorBuilder {
+    this._options.removeStaleWhenCommented = false;
+
+    return this;
+  }
+
+  removeStaleWhenCommented(): IssuesProcessorBuilder {
+    this._options.removeStaleWhenCommented = true;
+
+    return this;
+  }
+
+  unsetIssueStaleWhenCommented(): IssuesProcessorBuilder {
+    delete this._options.removeIssueStaleWhenCommented;
+
+    return this;
+  }
+
+  keepIssueStaleWhenCommented(): IssuesProcessorBuilder {
+    this._options.removeIssueStaleWhenCommented = false;
+
+    return this;
+  }
+
+  removeIssueStaleWhenCommented(): IssuesProcessorBuilder {
+    this._options.removeIssueStaleWhenCommented = true;
+
+    return this;
+  }
+
+  unsetPrStaleWhenCommented(): IssuesProcessorBuilder {
+    delete this._options.removePrStaleWhenCommented;
+
+    return this;
+  }
+
+  keepPrStaleWhenCommented(): IssuesProcessorBuilder {
+    this._options.removePrStaleWhenCommented = false;
+
+    return this;
+  }
+
+  removePrStaleWhenCommented(): IssuesProcessorBuilder {
+    this._options.removePrStaleWhenCommented = true;
+
+    return this;
+  }
+
+  issuesOrPrs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
+    this._issues = issues.map(
+      (issue: Readonly<Partial<IIssue>>, index: Readonly<number>): Issue =>
+        generateIssue(
+          this._options,
+          index,
+          issue.title ?? 'dummy-title',
+          issue.updated_at ?? new Date().toDateString(),
+          issue.created_at ?? new Date().toDateString(),
+          !!issue.pull_request,
+          issue.labels ? issue.labels.map(label => label.name) : []
+        )
+    );
+
+    return this;
+  }
+
+  issues(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
+    this.issuesOrPrs(
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: null
+        };
+      })
+    );
+
+    return this;
+  }
+
+  staleIssues(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
+    this.issues(
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          updated_at: '2020-01-01T17:00:00Z',
+          created_at: '2020-01-01T17:00:00Z',
+          labels: issue.labels?.map((label: Readonly<ILabel>): ILabel => {
+            return {
+              ...label,
+              name: 'Stale'
+            };
+          }) ?? [
+            {
+              name: 'Stale'
+            }
+          ]
+        };
+      })
+    );
+
+    return this;
+  }
+
+  prs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
+    this.issuesOrPrs(
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: {key: 'value'}
+        };
+      })
+    );
+
+    return this;
+  }
+
+  stalePrs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
+    this.prs(
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          updated_at: '2020-01-01T17:00:00Z',
+          created_at: '2020-01-01T17:00:00Z',
+          labels: issue.labels?.map((label: Readonly<ILabel>): ILabel => {
+            return {
+              ...label,
+              name: 'Stale'
+            };
+          }) ?? [
+            {
+              name: 'Stale'
+            }
+          ]
+        };
+      })
+    );
+
+    return this;
+  }
+
+  build(): IssuesProcessorMock {
+    return new IssuesProcessorMock(
+      this._options,
+      async () => 'abot',
+      async p => (p === 1 ? this._issues : []),
+      async () => [
+        {
+          // Note this comment
+          user: {
+            login: 'notme',
+            type: 'User'
+          }
+        }
+      ],
+      async () => new Date().toDateString()
+    );
+  }
+}
diff --git a/__tests__/remove-stale-when-updated.spec.ts b/__tests__/remove-stale-when-updated.spec.ts
index 24eeef5..26eb0af 100644
--- a/__tests__/remove-stale-when-updated.spec.ts
+++ b/__tests__/remove-stale-when-updated.spec.ts
@@ -11,7 +11,7 @@ let issuesProcessor: IssuesProcessorMock;
 
 /**
  * @description
- * Assuming there is a comment on the issue
+ * Assuming there is an update on the issue
  */
 describe('remove-stale-when-updated option', (): void => {
   beforeEach((): void => {
@@ -464,14 +464,12 @@ class IssuesProcessorBuilder {
 
   issues(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issuesOrPrs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            pull_request: null
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: null
+        };
+      })
     );
 
     return this;
@@ -479,27 +477,24 @@ class IssuesProcessorBuilder {
 
   staleIssues(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issues(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            updated_at: '2020-01-01T17:00:00Z',
-            created_at: '2020-01-01T17:00:00Z',
-            labels: issue.labels?.map(
-              (label: Readonly<ILabel>): ILabel => {
-                return {
-                  ...label,
-                  name: 'Stale'
-                };
-              }
-            ) ?? [
-              {
-                name: 'Stale'
-              }
-            ]
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          // Note this update
+          updated_at: new Date().toDateString(),
+          created_at: new Date().toDateString(),
+          labels: issue.labels?.map((label: Readonly<ILabel>): ILabel => {
+            return {
+              ...label,
+              name: 'Stale'
+            };
+          }) ?? [
+            {
+              name: 'Stale'
+            }
+          ]
+        };
+      })
     );
 
     return this;
@@ -507,14 +502,12 @@ class IssuesProcessorBuilder {
 
   prs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.issuesOrPrs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            pull_request: {key: 'value'}
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          pull_request: {key: 'value'}
+        };
+      })
     );
 
     return this;
@@ -522,27 +515,24 @@ class IssuesProcessorBuilder {
 
   stalePrs(issues: Partial<IIssue>[]): IssuesProcessorBuilder {
     this.prs(
-      issues.map(
-        (issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
-          return {
-            ...issue,
-            updated_at: '2020-01-01T17:00:00Z',
-            created_at: '2020-01-01T17:00:00Z',
-            labels: issue.labels?.map(
-              (label: Readonly<ILabel>): ILabel => {
-                return {
-                  ...label,
-                  name: 'Stale'
-                };
-              }
-            ) ?? [
-              {
-                name: 'Stale'
-              }
-            ]
-          };
-        }
-      )
+      issues.map((issue: Readonly<Partial<IIssue>>): Partial<IIssue> => {
+        return {
+          ...issue,
+          // Note this update
+          updated_at: new Date().toDateString(),
+          created_at: new Date().toDateString(),
+          labels: issue.labels?.map((label: Readonly<ILabel>): ILabel => {
+            return {
+              ...label,
+              name: 'Stale'
+            };
+          }) ?? [
+            {
+              name: 'Stale'
+            }
+          ]
+        };
+      })
     );
 
     return this;
@@ -553,14 +543,7 @@ class IssuesProcessorBuilder {
       this._options,
       async () => 'abot',
       async p => (p === 1 ? this._issues : []),
-      async () => [
-        {
-          user: {
-            login: 'notme',
-            type: 'User'
-          }
-        }
-      ],
+      async () => [],
       async () => new Date().toDateString()
     );
   }