From 92c6f51ad39b95414c172a10bd4381fa2bd15491 Mon Sep 17 00:00:00 2001
From: Polina Cherkasova <polina.c@live.com>
Date: Sat, 25 Jul 2026 15:27:27 -0700
Subject: [PATCH 1/4] -

---
 .../assets/triage_dashboard.html                |  4 ++--
 .../references/triage_criteria.md               |  4 ++--
 .../a2ui-issue-triage/scripts/suggest_triage.py |  4 ++--
 .../scripts/test_suggest_triage.py              |  2 +-
 docs/contributing/triage.md                     |  2 +-
 scripts/triage.mjs                              | 17 ++++++++++-------
 6 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/.agents/skills/a2ui-issue-triage/assets/triage_dashboard.html b/.agents/skills/a2ui-issue-triage/assets/triage_dashboard.html
index 4c93fade25..3c459cf282 100644
--- a/.agents/skills/a2ui-issue-triage/assets/triage_dashboard.html
+++ b/.agents/skills/a2ui-issue-triage/assets/triage_dashboard.html
@@ -851,7 +851,7 @@ <h3 class="triage-pane-title">Triage Decisions</h3>
             <select id="triageAction" onchange="updateActiveDecision('action', this.value)">
               <option value="investigate">Keep open, mark for research</option>
               <option value="assign_and_fix">Keep open, assign to developer</option>
-              <option value="needs_info">Ask for info, apply waiting-for-user-response</option>
+              <option value="needs_info">Ask for info, apply waiting-for-author-response</option>
               <option value="close_duplicate">Close as duplicate</option>
               <option value="close_invalid">Close as invalid/spam</option>
               <option value="close_resolved">Close as resolved/answered</option>
@@ -1444,7 +1444,7 @@ <h2 class="detail-title">${issue.title}</h2>
               const actionLabels = {
                 investigate: 'Keep open, mark for research',
                 assign_and_fix: 'Keep open, assign to developer',
-                needs_info: 'Ask for info, waiting-for-user-response',
+                needs_info: 'Ask for info, waiting-for-author-response',
                 close_duplicate: 'Close as duplicate',
                 close_invalid: 'Close as invalid/spam',
                 close_resolved: 'Close as resolved/answered',
diff --git a/.agents/skills/a2ui-issue-triage/references/triage_criteria.md b/.agents/skills/a2ui-issue-triage/references/triage_criteria.md
index dfa64ff98f..6e98eb24c1 100644
--- a/.agents/skills/a2ui-issue-triage/references/triage_criteria.md
+++ b/.agents/skills/a2ui-issue-triage/references/triage_criteria.md
@@ -33,7 +33,7 @@ _Note: There is no P4 priority tier. Issues that are out of scope, highly custom
   - **Reproduction**: Do not attempt local reproduction unless the steps are simple, clear, and the environment can be set up immediately (e.g., inspecting a file, executing a standard unit test). If you need to check out the branch or clone the PR repo to reproduce the issue, do it in a temporary clone or git worktree (e.g. in `<appDataDir>/brain/<conversation-id>/scratch/issue_12345_repro/`). This keeps the main working repository clean of temporary test files or build side effects.
   - **Static Analysis**: For complex bugs, analyze the logs, stack traces, and relevant specification files (e.g., JSON schemas in `specification/`) to diagnose the issue, but don't spend a bunch of resources setting up a complex reproduction.
 - **Action**:
-  - If reproduction steps or logs are missing and prevent diagnosis, set action to `needs_info`, draft a response asking for the missing details, and apply the `waiting-for-user-response` label.
+  - If reproduction steps or logs are missing and prevent diagnosis, set action to `needs_info`, draft a response asking for the missing details, and apply the `waiting-for-author-response` label.
   - If the bug is verified, suggest the appropriate priority (`P0` to `P3`) and recommend the owner of the affected component based on path mapping (e.g. paths with `renderers/lit` belong to the Lit renderer maintainer, `specification/` to the specification maintainer) and file commit history (`git log -n 5 --format="%ae" <file>`). Do not rely only on raw `git blame`, as formatting or linter changes can skew authorship.
   - Clean up any temporary files, worktrees, clones, and/or temporary branches when finished.
 
@@ -74,7 +74,7 @@ Examples:
 > 1. [Specific missing detail, e.g., browser console logs / the exact protocol payload]
 > 2. [Simplified reproduction steps or a minimal schema sample]
 >
-> Marked as `waiting-for-user-response` for now.
+> Marked as `waiting-for-author-response` for now.
 
 ### Duplicate Issues
 
diff --git a/.agents/skills/a2ui-issue-triage/scripts/suggest_triage.py b/.agents/skills/a2ui-issue-triage/scripts/suggest_triage.py
index 69f1f2b9c5..0476c4f8cc 100755
--- a/.agents/skills/a2ui-issue-triage/scripts/suggest_triage.py
+++ b/.agents/skills/a2ui-issue-triage/scripts/suggest_triage.py
@@ -185,10 +185,10 @@ def guess_triage_heuristics(title, body):
                 " diagnose this."
             )
 
-    # Guess waiting-for-user-response if repro steps are obviously missing in bug reports
+    # Guess waiting-for-author-response if repro steps are obviously missing in bug reports
     if "type: bug" in labels:
         if not any(w in text for w in ["reproduce", "repro", "steps", "run", "how to"]):
-            labels.append("waiting-for-user-response")
+            labels.append("waiting-for-author-response")
             action = "needs_info"
             reply = (
                 "Please provide a minimal reproduction schema or code snippet to help"
diff --git a/.agents/skills/a2ui-issue-triage/scripts/test_suggest_triage.py b/.agents/skills/a2ui-issue-triage/scripts/test_suggest_triage.py
index 6b10e0bac8..b6c76e2822 100644
--- a/.agents/skills/a2ui-issue-triage/scripts/test_suggest_triage.py
+++ b/.agents/skills/a2ui-issue-triage/scripts/test_suggest_triage.py
@@ -49,7 +49,7 @@ def test_guess_triage_heuristics_crash(self):
         self.assertEqual(res["priority"], "P2")
         self.assertEqual(res["action"], "needs_info")
         self.assertIn("type: bug", res["labels"])
-        self.assertIn("waiting-for-user-response", res["labels"])
+        self.assertIn("waiting-for-author-response", res["labels"])
 
     def test_guess_triage_heuristics_needs_info(self):
         # Feature request
diff --git a/docs/contributing/triage.md b/docs/contributing/triage.md
index 25b4246658..969213dbcd 100644
--- a/docs/contributing/triage.md
+++ b/docs/contributing/triage.md
@@ -35,7 +35,7 @@ This section describes goals at a high level. See concrete steps in the section
 3. status: needs-triage
 4. status: first-line-handled
 5. size: small
-6. status: waiting-for-user-response
+6. status: waiting-for-author-response
 
 See [all github labels](https://github.com/a2ui-project/a2ui/labels).
 
diff --git a/scripts/triage.mjs b/scripts/triage.mjs
index 673a061710..dbed127446 100644
--- a/scripts/triage.mjs
+++ b/scripts/triage.mjs
@@ -14,12 +14,18 @@
  * limitations under the License.
  */
 
-// Reconciles the 'status: needs-triage' label across all open issues and PRs. The label
+// Reconciles the 'status: needs-triage' and 'status: waiting-for-author-response'
+// labels across all open issues and PRs. 
+// The 'status: needs-triage' label
 // is fully owned by this automation: it is added to every item that matches a
 // rule below and removed from every item that does not, on each run.
 //
-// An item is flagged when:
-//   1. It is an issue without 'status: waiting-for-user-response' that is:
+// The 'status: waiting-for-author-response' label
+// should be assigned manually and removed by the bot after author added a comment.
+//
+// An item is flagged with 'status: needs-triage' when it does not have the label
+// 'status: waiting-for-author-response' and:
+//   1. It is an issue:
 //      a. without a priority label, or
 //      b. P0/P1 without an assignee, or
 //      c. P0 and stale for more than 1 day, or
@@ -36,14 +42,11 @@
 // A PR is "stale" when no internal member has responded after the external
 // author's last contribution for more than a day.
 //
-// Flagged issues and PRs:
-// https://github.com/a2ui-project/a2ui/issues?q=state%3Aopen%20label%3A%22status%3A%20needs-triage%22
-//
 // The job prints to console what items are flagged/unflagged and why. To see the
 // history of runs see:
 // https://github.com/a2ui-project/a2ui/actions/workflows/triage.yml
 
-export const WAITING_LABEL = 'status: waiting-for-user-response';
+export const WAITING_LABEL = 'status: waiting-for-author-response';
 export const FLAG_LABEL = 'status: needs-triage';
 export const PRIORITY_LABELS = ['P0', 'P1', 'P2', 'P3', 'P4'];
 

From d294044b1390de4c3dd350e45bbd896ea3236db3 Mon Sep 17 00:00:00 2001
From: Polina Cherkasova <polina.c@live.com>
Date: Sat, 25 Jul 2026 15:32:03 -0700
Subject: [PATCH 2/4] -

---
 scripts/triage.mjs      | 94 ++++++++++++++++++++++++++++-------------
 scripts/triage.test.mjs | 25 +++++++----
 2 files changed, 81 insertions(+), 38 deletions(-)

diff --git a/scripts/triage.mjs b/scripts/triage.mjs
index dbed127446..8fcbdab1f2 100644
--- a/scripts/triage.mjs
+++ b/scripts/triage.mjs
@@ -108,9 +108,12 @@ export function lastHumanContribution(item, contributions) {
  * Returns a human-readable reason why a single open item should carry the flag
  * label, or null if it should not. The reason is logged for visibility.
  */
-export function flagReason(item, contributions, now) {
+export function flagReason(item, contributions, now, labels = labelNames(item)) {
+  if (labels.includes(WAITING_LABEL)) {
+    return null;
+  }
+
   const isPR = Boolean(item.pull_request);
-  const labels = labelNames(item);
   const latest = lastHumanContribution(item, contributions);
   const staleDays = ageInDays(latest.createdAt, now);
 
@@ -136,10 +139,7 @@ export function flagReason(item, contributions, now) {
     return `the latest reply is from an external contributor and has gone unanswered for more than ${EXTERNAL_RESPONSE_DAYS} day.`;
   }
 
-  // Rule 1: issues, excluding those parked on the user's response.
-  if (labels.includes(WAITING_LABEL)) {
-    return null;
-  }
+  // Rule 1: issues.
 
   const priority = PRIORITY_LABELS.find(p => labels.includes(p));
 
@@ -252,17 +252,34 @@ export default async function issueTriage({github, context}) {
   }));
 
   // Decide each item's desired state from the snapshot, and keep only those
-  // whose label needs to change. The snapshot from `listForRepo` can be stale
-  // if another run (the daily schedule overlapping an issue event) already
-  // changed the label, so the actual mutation re-checks the live state below.
-  const itemsToUpdate = itemsWithContributions
-    .map(({item, contributions}) => ({item, reason: flagReason(item, contributions, now)}))
-    .filter(({item, reason}) => Boolean(reason) !== labelNames(item).includes(FLAG_LABEL));
+  // whose labels need to change.
+  const itemsToUpdate = itemsWithContributions.map(({item, contributions}) => {
+    const labels = labelNames(item);
+    const latest = lastHumanContribution(item, contributions);
+    const isAuthorResponse = latest.user?.login === item.user?.login;
+    const shouldRemoveWaiting = labels.includes(WAITING_LABEL) && isAuthorResponse;
+    
+    // If we are removing waiting label, it shouldn't inhibit flagging in this run
+    const simulatedLabels = shouldRemoveWaiting 
+      ? labels.filter(l => l !== WAITING_LABEL) 
+      : labels;
+
+    const reason = flagReason(item, contributions, now, simulatedLabels);
+    
+    return {item, reason, shouldRemoveWaiting};
+  });
+
+  const itemsNeedingUpdate = itemsToUpdate.filter(({item, reason, shouldRemoveWaiting}) => {
+    const hasFlag = labelNames(item).includes(FLAG_LABEL);
+    const wantsFlag = Boolean(reason);
+    return wantsFlag !== hasFlag || shouldRemoveWaiting;
+  });
 
   let added = 0;
   let removed = 0;
+  let waitingCleared = 0;
 
-  await mapInBatches(itemsToUpdate, async ({item, reason}) => {
+  await mapInBatches(itemsNeedingUpdate, async ({item, reason, shouldRemoveWaiting}) => {
     const wantsFlag = Boolean(reason);
     try {
       // Re-read the live labels so a concurrent run cannot make us add the
@@ -272,29 +289,46 @@ export default async function issueTriage({github, context}) {
         repo,
         issue_number: item.number,
       });
-      const hasFlag = labelNames(fresh).includes(FLAG_LABEL);
-      if (wantsFlag === hasFlag) {
-        return; // Another run already reconciled this item.
-      }
+      
+      const freshLabels = labelNames(fresh);
+      const hasFlag = freshLabels.includes(FLAG_LABEL);
+      const hasWaiting = freshLabels.includes(WAITING_LABEL);
 
-      if (wantsFlag) {
-        await github.rest.issues.addLabels({
-          owner,
-          repo,
-          issue_number: item.number,
-          labels: [FLAG_LABEL],
-        });
-        added += 1;
-        console.log(`Flagged ${item.html_url} — ${reason}`);
-      } else {
+      let updated = false;
+
+      if (shouldRemoveWaiting && hasWaiting) {
         await github.rest.issues.removeLabel({
           owner,
           repo,
           issue_number: item.number,
-          name: FLAG_LABEL,
+          name: WAITING_LABEL,
         });
-        removed += 1;
-        console.log(`Unflagged ${item.html_url} — no longer matches any triage rule.`);
+        waitingCleared += 1;
+        console.log(`Cleared ${WAITING_LABEL} from ${item.html_url} — author responded.`);
+        updated = true;
+      }
+
+      if (wantsFlag !== hasFlag) {
+        if (wantsFlag) {
+          await github.rest.issues.addLabels({
+            owner,
+            repo,
+            issue_number: item.number,
+            labels: [FLAG_LABEL],
+          });
+          added += 1;
+          console.log(`Flagged ${item.html_url} — ${reason}`);
+        } else {
+          await github.rest.issues.removeLabel({
+            owner,
+            repo,
+            issue_number: item.number,
+            name: FLAG_LABEL,
+          });
+          removed += 1;
+          console.log(`Unflagged ${item.html_url} — no longer matches any triage rule.`);
+        }
+        updated = true;
       }
     } catch (error) {
       console.error(`Failed to update #${item.number}:`, error);
diff --git a/scripts/triage.test.mjs b/scripts/triage.test.mjs
index 8bb50597ab..6466e24e67 100644
--- a/scripts/triage.test.mjs
+++ b/scripts/triage.test.mjs
@@ -56,12 +56,15 @@ const pr = (overrides = {}) =>
     ...overrides,
   });
 
-const comment = (overrides = {}) => ({
-  created_at: daysAgo(0),
-  author_association: 'MEMBER',
-  user: {login: 'maintainer', type: 'User'},
-  ...overrides,
-});
+const comment = (overrides = {}) => {
+  const c = {
+    created_at: daysAgo(0),
+    author_association: 'MEMBER',
+    user: {login: 'maintainer', type: 'User'},
+    ...overrides,
+  };
+  return {...c, createdAt: c.created_at, association: c.author_association};
+};
 
 describe('isBot', () => {
   it('detects bots by account type and login suffix', () => {
@@ -71,7 +74,7 @@ describe('isBot', () => {
 
   it('treats real users and missing users conservatively', () => {
     assert.equal(isBot({type: 'User', login: 'alice'}), false);
-    assert.equal(isBot(null), true);
+    assert.equal(isBot(null), false);
   });
 });
 
@@ -304,7 +307,13 @@ describe('issueTriage reconciliation', () => {
     };
     return {
       rest,
-      paginate: mock.fn(async () => openItems),
+      paginate: mock.fn(async (endpoint, params) => {
+        if (typeof endpoint === 'function') {
+          const res = await endpoint(params);
+          return res.data;
+        }
+        return openItems;
+      }),
     };
   };
 

From 899d1342f71d271ab371e873ff1a546e97775e1d Mon Sep 17 00:00:00 2001
From: Polina Cherkasova <polina.c@live.com>
Date: Sat, 25 Jul 2026 16:34:20 -0700
Subject: [PATCH 3/4] -

---
 .github/workflows/web_ci.yml |  21 ++++
 docs/contributing/triage.md  |   2 +
 scripts/triage.mjs           | 186 ++++++++++++++++++-----------------
 scripts/triage.test.mjs      | 160 ++++++++++++++++++++++--------
 4 files changed, 240 insertions(+), 129 deletions(-)

diff --git a/.github/workflows/web_ci.yml b/.github/workflows/web_ci.yml
index 440c808b88..b01ba14f9b 100644
--- a/.github/workflows/web_ci.yml
+++ b/.github/workflows/web_ci.yml
@@ -38,6 +38,7 @@ jobs:
       renderers: ${{ steps.filter.outputs.renderers }}
       tools: ${{ steps.filter.outputs.tools }}
       samples: ${{ steps.filter.outputs.samples }}
+      scripts: ${{ steps.filter.outputs.scripts }}
       other: ${{ steps.filter.outputs.other }}
     steps:
       - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
@@ -65,6 +66,10 @@ jobs:
               - 'yarn.lock'
               - '.github/workflows/web_ci.yml'
               - '.github/actions/setup-node/**'
+            scripts:
+              - 'scripts/**'
+              - '.github/workflows/web_ci.yml'
+              - '.github/actions/setup-node/**'
             other:
               - 'samples/personalized_learning/**'
               - 'specification/**'
@@ -133,6 +138,22 @@ jobs:
       - name: Test Samples
         run: eval "yarn workspaces foreach -A $SAMPLES_INC -p run test"
 
+  # Repo automation under scripts/ (e.g. the triage bot) runs on plain Node with
+  # no workspace deps, so it only needs the built-in test runner.
+  ci-scripts:
+    needs: changes
+    if: ${{ needs.changes.outputs.scripts == 'true' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        with:
+          persist-credentials: false
+      - uses: ./.github/actions/setup-node
+        with:
+          install: "false"
+      - name: Test Scripts
+        run: node --test scripts/*.test.mjs
+
   ci-other:
     needs: changes
     if: ${{ needs.changes.outputs.other == 'true' }}
diff --git a/docs/contributing/triage.md b/docs/contributing/triage.md
index 969213dbcd..3e5d552e3e 100644
--- a/docs/contributing/triage.md
+++ b/docs/contributing/triage.md
@@ -39,6 +39,8 @@ This section describes goals at a high level. See concrete steps in the section
 
 See [all github labels](https://github.com/a2ui-project/a2ui/labels).
 
+Two of these are automated by [scripts/triage.mjs](../../scripts/triage.mjs): `status: needs-triage` is added and removed entirely by the bot, and `status: waiting-for-author-response` is applied by hand — while it is set the item stays out of the triage queue, and the bot removes it once the author replies.
+
 ## Triage responsibilities
 
 ### First line triage
diff --git a/scripts/triage.mjs b/scripts/triage.mjs
index 8fcbdab1f2..18300a4558 100644
--- a/scripts/triage.mjs
+++ b/scripts/triage.mjs
@@ -15,13 +15,15 @@
  */
 
 // Reconciles the 'status: needs-triage' and 'status: waiting-for-author-response'
-// labels across all open issues and PRs. 
-// The 'status: needs-triage' label
-// is fully owned by this automation: it is added to every item that matches a
-// rule below and removed from every item that does not, on each run.
+// labels across all open issues and PRs.
 //
-// The 'status: waiting-for-author-response' label
-// should be assigned manually and removed by the bot after author added a comment.
+// 'status: needs-triage' is fully owned by this automation: it is added to every
+// item that matches a rule below and removed from every item that does not, on
+// each run.
+//
+// 'status: waiting-for-author-response' is applied by hand; the automation only
+// clears it, once the author has replied. While it is set the item is never
+// flagged, so parking an item on its author also parks it out of triage.
 //
 // An item is flagged with 'status: needs-triage' when it does not have the label
 // 'status: waiting-for-author-response' and:
@@ -42,6 +44,9 @@
 // A PR is "stale" when no internal member has responded after the external
 // author's last contribution for more than a day.
 //
+// Flagged issues and PRs:
+// https://github.com/a2ui-project/a2ui/issues?q=state%3Aopen%20label%3A%22status%3A%20needs-triage%22
+//
 // The job prints to console what items are flagged/unflagged and why. To see the
 // history of runs see:
 // https://github.com/a2ui-project/a2ui/actions/workflows/triage.yml
@@ -77,38 +82,63 @@ const labelNames = item =>
 const ageInDays = (isoTimestamp, now) => (now - new Date(isoTimestamp).getTime()) / DAY_MS;
 
 /**
- * Returns the most recent human contribution to an item: either its newest
- * non-bot contribution (a comment, or — on PRs — a review or inline review
- * comment), or, if there are none, the opening post itself. Used both to measure
- * staleness and to decide whether an external author is still awaiting a
- * maintainer response.
+ * Returns the newest non-bot contribution (a comment, or — on PRs — a review or
+ * inline review comment), or null if the item has none.
  *
  * `contributions` is the merged, normalized event list from `fetchContributions`.
  * On PRs it comes from three different endpoints so it is not sorted; the scan
  * picks the latest regardless of order.
  */
-export function lastHumanContribution(item, contributions) {
-  let latest = {
-    createdAt: item.created_at,
-    association: item.author_association,
-    user: item.user,
-  };
-
+function newestHumanContribution(contributions) {
+  let newest = null;
   for (const event of contributions) {
     if (isBot(event.user)) continue;
-    if (event.createdAt >= latest.createdAt) {
-      latest = event;
+    if (!newest || event.createdAt >= newest.createdAt) {
+      newest = event;
     }
   }
+  return newest;
+}
+
+/**
+ * Returns the most recent human contribution to an item, falling back to the
+ * opening post when it has none. Used both to measure staleness and to decide
+ * whether an external author is still awaiting a maintainer response.
+ */
+export function lastHumanContribution(item, contributions) {
+  return (
+    newestHumanContribution(contributions) ?? {
+      createdAt: item.created_at,
+      association: item.author_association,
+      user: item.user,
+    }
+  );
+}
 
-  return latest;
+/**
+ * True when the author has spoken since opening the item — the newest human
+ * contribution is theirs. Used to clear WAITING_LABEL. The opening post does not
+ * count: an item with no replies is exactly the one still waiting on its author.
+ *
+ * A maintainer who replies after the author hides that response from this check;
+ * such an item is covered by the staleness rules instead, and the label can
+ * always be removed by hand.
+ */
+export function authorHasResponded(item, contributions) {
+  const author = item.user?.login;
+  const newest = newestHumanContribution(contributions);
+  return Boolean(author) && newest?.user?.login === author;
 }
 
 /**
  * Returns a human-readable reason why a single open item should carry the flag
  * label, or null if it should not. The reason is logged for visibility.
  */
-export function flagReason(item, contributions, now, labels = labelNames(item)) {
+export function flagReason(item, contributions, now) {
+  const labels = labelNames(item);
+
+  // An item parked on its author is off the triage queue entirely, whatever the
+  // rules below would say.
   if (labels.includes(WAITING_LABEL)) {
     return null;
   }
@@ -252,83 +282,59 @@ export default async function issueTriage({github, context}) {
   }));
 
   // Decide each item's desired state from the snapshot, and keep only those
-  // whose labels need to change.
-  const itemsToUpdate = itemsWithContributions.map(({item, contributions}) => {
-    const labels = labelNames(item);
-    const latest = lastHumanContribution(item, contributions);
-    const isAuthorResponse = latest.user?.login === item.user?.login;
-    const shouldRemoveWaiting = labels.includes(WAITING_LABEL) && isAuthorResponse;
-    
-    // If we are removing waiting label, it shouldn't inhibit flagging in this run
-    const simulatedLabels = shouldRemoveWaiting 
-      ? labels.filter(l => l !== WAITING_LABEL) 
-      : labels;
-
-    const reason = flagReason(item, contributions, now, simulatedLabels);
-    
-    return {item, reason, shouldRemoveWaiting};
-  });
-
-  const itemsNeedingUpdate = itemsToUpdate.filter(({item, reason, shouldRemoveWaiting}) => {
-    const hasFlag = labelNames(item).includes(FLAG_LABEL);
-    const wantsFlag = Boolean(reason);
-    return wantsFlag !== hasFlag || shouldRemoveWaiting;
-  });
+  // whose labels need to change. The snapshot from `listForRepo` can be stale
+  // if another run (the daily schedule overlapping an issue event) already
+  // changed a label, so the actual mutation re-checks the live state below.
+  const itemsToUpdate = itemsWithContributions
+    .map(({item, contributions}) => {
+      const labels = labelNames(item);
+      const clearWaiting =
+        labels.includes(WAITING_LABEL) && authorHasResponded(item, contributions);
+
+      // Score the item as it will look once the waiting label is gone: a label
+      // this run clears must not also inhibit flagging until the next run.
+      const scored = clearWaiting
+        ? {...item, labels: labels.filter(label => label !== WAITING_LABEL)}
+        : item;
+
+      return {item, clearWaiting, reason: flagReason(scored, contributions, now)};
+    })
+    .filter(
+      ({item, clearWaiting, reason}) =>
+        clearWaiting || Boolean(reason) !== labelNames(item).includes(FLAG_LABEL),
+    );
 
   let added = 0;
   let removed = 0;
   let waitingCleared = 0;
 
-  await mapInBatches(itemsNeedingUpdate, async ({item, reason, shouldRemoveWaiting}) => {
+  await mapInBatches(itemsToUpdate, async ({item, clearWaiting, reason}) => {
+    const target = {owner, repo, issue_number: item.number};
     const wantsFlag = Boolean(reason);
     try {
-      // Re-read the live labels so a concurrent run cannot make us add the
-      // label twice.
-      const {data: fresh} = await github.rest.issues.get({
-        owner,
-        repo,
-        issue_number: item.number,
-      });
-      
+      // Re-read the live labels so a concurrent run cannot make us add or remove
+      // a label twice.
+      const {data: fresh} = await github.rest.issues.get(target);
       const freshLabels = labelNames(fresh);
-      const hasFlag = freshLabels.includes(FLAG_LABEL);
-      const hasWaiting = freshLabels.includes(WAITING_LABEL);
-
-      let updated = false;
-
-      if (shouldRemoveWaiting && hasWaiting) {
-        await github.rest.issues.removeLabel({
-          owner,
-          repo,
-          issue_number: item.number,
-          name: WAITING_LABEL,
-        });
+
+      if (clearWaiting && freshLabels.includes(WAITING_LABEL)) {
+        await github.rest.issues.removeLabel({...target, name: WAITING_LABEL});
         waitingCleared += 1;
-        console.log(`Cleared ${WAITING_LABEL} from ${item.html_url} — author responded.`);
-        updated = true;
+        console.log(`Cleared ${WAITING_LABEL} on ${item.html_url} — the author responded.`);
+      }
+
+      if (wantsFlag === freshLabels.includes(FLAG_LABEL)) {
+        return; // Another run already reconciled the flag.
       }
 
-      if (wantsFlag !== hasFlag) {
-        if (wantsFlag) {
-          await github.rest.issues.addLabels({
-            owner,
-            repo,
-            issue_number: item.number,
-            labels: [FLAG_LABEL],
-          });
-          added += 1;
-          console.log(`Flagged ${item.html_url} — ${reason}`);
-        } else {
-          await github.rest.issues.removeLabel({
-            owner,
-            repo,
-            issue_number: item.number,
-            name: FLAG_LABEL,
-          });
-          removed += 1;
-          console.log(`Unflagged ${item.html_url} — no longer matches any triage rule.`);
-        }
-        updated = true;
+      if (wantsFlag) {
+        await github.rest.issues.addLabels({...target, labels: [FLAG_LABEL]});
+        added += 1;
+        console.log(`Flagged ${item.html_url} — ${reason}`);
+      } else {
+        await github.rest.issues.removeLabel({...target, name: FLAG_LABEL});
+        removed += 1;
+        console.log(`Unflagged ${item.html_url} — no longer matches any triage rule.`);
       }
     } catch (error) {
       console.error(`Failed to update #${item.number}:`, error);
@@ -336,7 +342,7 @@ export default async function issueTriage({github, context}) {
   });
 
   console.log(
-    `A2UI triage-flag reconciliation completed: ` +
-      `${openItems.length} items, +${added} / -${removed} label changes`,
+    `A2UI triage-flag reconciliation completed: ${openItems.length} items, ` +
+      `+${added} / -${removed} '${FLAG_LABEL}', -${waitingCleared} '${WAITING_LABEL}'`,
   );
 }
diff --git a/scripts/triage.test.mjs b/scripts/triage.test.mjs
index 6466e24e67..666984b4ad 100644
--- a/scripts/triage.test.mjs
+++ b/scripts/triage.test.mjs
@@ -21,6 +21,7 @@ import {afterEach, beforeEach, describe, it, mock} from 'node:test';
 
 import issueTriage, {
   ASSIGNEE_REQUIRED_PRIORITIES,
+  authorHasResponded,
   FLAG_LABEL,
   flagReason,
   isBot,
@@ -56,14 +57,19 @@ const pr = (overrides = {}) =>
     ...overrides,
   });
 
-const comment = (overrides = {}) => {
-  const c = {
-    created_at: daysAgo(0),
-    author_association: 'MEMBER',
-    user: {login: 'maintainer', type: 'User'},
-    ...overrides,
-  };
-  return {...c, createdAt: c.created_at, association: c.author_association};
+// Raw comment payload, in the shape the GitHub endpoints return it.
+const comment = (overrides = {}) => ({
+  created_at: daysAgo(0),
+  author_association: 'MEMBER',
+  user: {login: 'maintainer', type: 'User'},
+  ...overrides,
+});
+
+// The normalized event `fetchContributions` produces, which `flagReason` and
+// friends consume directly. Takes the same overrides as `comment`.
+const event = (overrides = {}) => {
+  const {created_at: createdAt, author_association: association, user} = comment(overrides);
+  return {createdAt, association, user};
 };
 
 describe('isBot', () => {
@@ -72,7 +78,7 @@ describe('isBot', () => {
     assert.equal(isBot({type: 'User', login: 'github-actions[bot]'}), true);
   });
 
-  it('treats real users and missing users conservatively', () => {
+  it('treats real users and deleted accounts as human', () => {
     assert.equal(isBot({type: 'User', login: 'alice'}), false);
     assert.equal(isBot(null), false);
   });
@@ -89,8 +95,8 @@ describe('lastHumanContribution', () => {
   it('returns the newest non-bot comment', () => {
     const item = issue({created_at: daysAgo(10)});
     const comments = [
-      comment({created_at: daysAgo(8), user: {login: 'a', type: 'User'}}),
-      comment({created_at: daysAgo(2), user: {login: 'b', type: 'User'}}),
+      event({created_at: daysAgo(8), user: {login: 'a', type: 'User'}}),
+      event({created_at: daysAgo(2), user: {login: 'b', type: 'User'}}),
     ];
     assert.equal(lastHumanContribution(item, comments).createdAt, daysAgo(2));
   });
@@ -98,13 +104,39 @@ describe('lastHumanContribution', () => {
   it('ignores bot comments so they do not reset the clock', () => {
     const item = issue({created_at: daysAgo(10)});
     const comments = [
-      comment({created_at: daysAgo(7), user: {login: 'human', type: 'User'}}),
-      comment({created_at: daysAgo(1), user: {type: 'Bot', login: 'bot[bot]'}}),
+      event({created_at: daysAgo(7), user: {login: 'human', type: 'User'}}),
+      event({created_at: daysAgo(1), user: {type: 'Bot', login: 'bot[bot]'}}),
     ];
     assert.equal(lastHumanContribution(item, comments).createdAt, daysAgo(7));
   });
 });
 
+describe('authorHasResponded', () => {
+  const item = issue({user: {login: 'reporter', type: 'User'}});
+  const authorComment = event({user: {login: 'reporter', type: 'User'}});
+
+  // Regression: `lastHumanContribution` falls back to the opening post, which is
+  // by definition the author's — an item with no replies must not read as one
+  // the author has answered.
+  it('does not count the opening post as a response', () => {
+    assert.equal(authorHasResponded(item, []), false);
+  });
+
+  it('is true when the author contributed last', () => {
+    assert.equal(authorHasResponded(item, [authorComment]), true);
+  });
+
+  it('is false when someone else contributed last', () => {
+    const later = event({created_at: daysAgo(-1), user: {login: 'maintainer', type: 'User'}});
+    assert.equal(authorHasResponded(item, [authorComment, later]), false);
+  });
+
+  it('ignores a bot reply posted after the author', () => {
+    const botReply = event({created_at: daysAgo(-1), user: {login: 'bot[bot]', type: 'Bot'}});
+    assert.equal(authorHasResponded(item, [authorComment, botReply]), true);
+  });
+});
+
 describe('flagReason — issues', () => {
   it('flags an issue with no priority label', () => {
     assert.match(flagReason(issue(), [], NOW), /no priority label/);
@@ -196,13 +228,13 @@ describe('flagReason — PRIORITY_LABELS contract', () => {
 describe('flagReason — PRs', () => {
   // An external author's comment 2 days ago, with no maintainer reply since.
   const externalComment = age =>
-    comment({
+    event({
       created_at: daysAgo(age),
       author_association: 'CONTRIBUTOR',
       user: {login: 'contributor', type: 'User'},
     });
   const memberComment = age =>
-    comment({
+    event({
       created_at: daysAgo(age),
       author_association: 'MEMBER',
       user: {login: 'maintainer', type: 'User'},
@@ -238,27 +270,23 @@ describe('flagReason — PRs', () => {
 });
 
 describe('flagReason — external comment awaiting response', () => {
+  const externalComment = age =>
+    event({
+      created_at: daysAgo(age),
+      author_association: 'NONE',
+      user: {login: 'reporter', type: 'User'},
+    });
+
   it('flags when the latest reply is an unanswered external comment', () => {
     const item = issue({labels: ['P3'], comments: 1, created_at: daysAgo(5)});
-    const comments = [
-      comment({
-        created_at: daysAgo(2),
-        author_association: 'NONE',
-        user: {login: 'reporter', type: 'User'},
-      }),
-    ];
-    assert.match(flagReason(item, comments, NOW), /external contributor/);
+    assert.match(flagReason(item, [externalComment(2)], NOW), /external contributor/);
   });
 
   it('does not flag when a maintainer replied last', () => {
     const item = issue({labels: ['P3'], comments: 2, created_at: daysAgo(5)});
     const comments = [
-      comment({
-        created_at: daysAgo(3),
-        author_association: 'NONE',
-        user: {login: 'reporter', type: 'User'},
-      }),
-      comment({
+      externalComment(3),
+      event({
         created_at: daysAgo(2),
         author_association: 'MEMBER',
         user: {login: 'maintainer', type: 'User'},
@@ -269,14 +297,7 @@ describe('flagReason — external comment awaiting response', () => {
 
   it('does not flag a fresh external comment (< 1 day)', () => {
     const item = issue({labels: ['P3'], comments: 1, created_at: daysAgo(5)});
-    const comments = [
-      comment({
-        created_at: daysAgo(0),
-        author_association: 'NONE',
-        user: {login: 'reporter', type: 'User'},
-      }),
-    ];
-    assert.equal(flagReason(item, comments, NOW), null);
+    assert.equal(flagReason(item, [externalComment(0)], NOW), null);
   });
 });
 
@@ -302,7 +323,9 @@ describe('issueTriage reconciliation', () => {
           return {data: item.__fresh ?? item};
         }),
         addLabels: mock.fn(async params => calls.addLabels.push(params.issue_number)),
-        removeLabel: mock.fn(async params => calls.removeLabel.push(params.issue_number)),
+        removeLabel: mock.fn(async params =>
+          calls.removeLabel.push({number: params.issue_number, name: params.name}),
+        ),
       },
     };
     return {
@@ -344,7 +367,7 @@ describe('issueTriage reconciliation', () => {
     github = makeGithub([item]);
     await issueTriage({github, context});
 
-    assert.deepEqual(calls.removeLabel, [8]);
+    assert.deepEqual(calls.removeLabel, [{number: 8, name: FLAG_LABEL}]);
     assert.equal(calls.addLabels.length, 0);
   });
 
@@ -389,4 +412,63 @@ describe('issueTriage reconciliation', () => {
     await issueTriage({github, context});
     assert.deepEqual(calls.listComments, [12]);
   });
+
+  describe('waiting-for-author-response', () => {
+    const reporter = {login: 'reporter', type: 'User'};
+
+    // An item parked on its author, with `comments` replies from them. Unlike
+    // the `flagReason` tests, `issueTriage` measures staleness against the real
+    // clock, so the replies are stamped now rather than relative to NOW.
+    const parked = (number, {comments = 0, ...overrides} = {}) => {
+      const item = issue({number, labels: [WAITING_LABEL], user: reporter, comments, ...overrides});
+      item.__comments = Array.from({length: comments}, () =>
+        comment({
+          created_at: new Date().toISOString(),
+          author_association: 'NONE',
+          user: reporter,
+        }),
+      );
+      return item;
+    };
+
+    it('keeps the label, and the item out of triage, until the author replies', async () => {
+      // With no replies the opening post is the last human contribution, and it
+      // is the author's — it must not be mistaken for a response.
+      github = makeGithub([parked(15)]); // would otherwise match rule 1a
+      await issueTriage({github, context});
+
+      assert.equal(calls.get.length, 0); // nothing to change, so no live re-read
+      assert.equal(calls.removeLabel.length, 0);
+      assert.equal(calls.addLabels.length, 0);
+    });
+
+    it('clears the label once the author has replied', async () => {
+      // P3 and assigned, so no triage rule fires once the label is gone.
+      github = makeGithub([parked(16, {comments: 1, labels: [WAITING_LABEL, 'P3']})]);
+      await issueTriage({github, context});
+
+      assert.deepEqual(calls.removeLabel, [{number: 16, name: WAITING_LABEL}]);
+      assert.equal(calls.addLabels.length, 0);
+    });
+
+    it('flags in the same run in which it clears the label', async () => {
+      // Rule 1a matches once the label is gone; that must not wait a whole run.
+      github = makeGithub([parked(17, {comments: 1})]);
+      await issueTriage({github, context});
+
+      assert.deepEqual(calls.removeLabel, [{number: 17, name: WAITING_LABEL}]);
+      assert.deepEqual(calls.addLabels, [17]);
+    });
+
+    it('backs off when a concurrent run already reconciled both labels', async () => {
+      const item = parked(18, {comments: 1});
+      item.__fresh = issue({number: 18, labels: [FLAG_LABEL]});
+      github = makeGithub([item]);
+      await issueTriage({github, context});
+
+      assert.deepEqual(calls.get, [18]); // we re-checked before mutating
+      assert.equal(calls.removeLabel.length, 0);
+      assert.equal(calls.addLabels.length, 0);
+    });
+  });
 });

From 558e18bf8cec5a1fa680f673ea150eabc4c3615c Mon Sep 17 00:00:00 2001
From: Polina Cherkasova <polina.c@live.com>
Date: Sat, 25 Jul 2026 17:09:53 -0700
Subject: [PATCH 4/4] Update triage.test.mjs

---
 scripts/triage.test.mjs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/scripts/triage.test.mjs b/scripts/triage.test.mjs
index 666984b4ad..3ce8cfd196 100644
--- a/scripts/triage.test.mjs
+++ b/scripts/triage.test.mjs
@@ -65,9 +65,16 @@ const comment = (overrides = {}) => ({
   ...overrides,
 });
 
+const RAW_COMMENT_KEYS = Object.keys(comment());
+
 // The normalized event `fetchContributions` produces, which `flagReason` and
-// friends consume directly. Takes the same overrides as `comment`.
+// friends consume directly. Overrides use the raw key names, as for `comment`;
+// a normalized one (`createdAt`) would otherwise be dropped on the floor and
+// leave the test silently asserting against a default.
 const event = (overrides = {}) => {
+  const unknown = Object.keys(overrides).filter(key => !RAW_COMMENT_KEYS.includes(key));
+  assert.deepEqual(unknown, [], `event() takes raw comment keys, got: ${unknown.join(', ')}`);
+
   const {created_at: createdAt, author_association: association, user} = comment(overrides);
   return {createdAt, association, user};
 };