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/.github/workflows/triage.yml b/.github/workflows/triage.yml
index 8eecadcda7..208f893e5c 100644
--- a/.github/workflows/triage.yml
+++ b/.github/workflows/triage.yml
@@ -32,8 +32,6 @@ on:
     types: [opened, edited, labeled, unlabeled, assigned, unassigned, reopened]
   issue_comment:
     types: [created]
-  pull_request_target:
-    types: [opened, edited, reopened, ready_for_review, synchronize]
   pull_request_review:
     types: [submitted]
   pull_request_review_comment:
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 25b4246658..526088e6c4 100644
--- a/docs/contributing/triage.md
+++ b/docs/contributing/triage.md
@@ -35,10 +35,12 @@ 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).
 
+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 has posted a reply, review, or review comment after the label went on. Replies from anyone else do not clear it, and neither does the author pushing commits without saying anything; remove it by hand in those cases.
+
 ## Triage responsibilities
 
 ### First line triage
diff --git a/scripts/triage.mjs b/scripts/triage.mjs
index 673a061710..9f5499dd80 100644
--- a/scripts/triage.mjs
+++ b/scripts/triage.mjs
@@ -14,12 +14,21 @@
  * limitations under the License.
  */
 
-// Reconciles the 'status: needs-triage' label across all open issues and PRs. The 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.
+// Reconciles the 'status: needs-triage' and 'status: waiting-for-author-response'
+// labels across all open issues and PRs.
 //
-// An item is flagged when:
-//   1. It is an issue without 'status: waiting-for-user-response' that is:
+// '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 contributed at least once after the label went
+// on. 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:
+//   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
@@ -43,7 +52,7 @@
 // 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'];
 
@@ -101,13 +110,43 @@ export function lastHumanContribution(item, contributions) {
   return latest;
 }
 
+/**
+ * True when the author has answered the request WAITING_LABEL is tracking: they
+ * contributed at least once at or after `waitingSince`, the moment the label was
+ * added. Used to clear the label.
+ *
+ * Only the author's own contributions count, and only those from after the label
+ * went on. The opening post predates it, so an item with no replies is exactly
+ * the one still waiting on its author. Contributions from anyone else are
+ * irrelevant in both directions: they do not answer on the author's behalf, and
+ * one landing after the author's reply does not hide it.
+ *
+ * `waitingSince` is null when the labeling could not be read — see
+ * `waitingLabelAddedAt`. The label is then left for a human to clear rather than
+ * guessed at.
+ */
+export function authorHasResponded(item, contributions, waitingSince) {
+  const author = item.user?.login;
+  if (!author || !waitingSince) return false;
+  return contributions.some(
+    event => event.user?.login === author && event.createdAt >= waitingSince,
+  );
+}
+
 /**
  * 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) {
-  const isPR = Boolean(item.pull_request);
   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;
+  }
+
+  const isPR = Boolean(item.pull_request);
   const latest = lastHumanContribution(item, contributions);
   const staleDays = ageInDays(latest.createdAt, now);
 
@@ -133,10 +172,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));
 
@@ -227,6 +263,43 @@ async function fetchContributions({github, owner, repo}, item) {
   return [...issueComments, ...reviews, ...reviewComments].map(toEvent);
 }
 
+/**
+ * Returns when WAITING_LABEL was most recently added to an item, or null when
+ * that cannot be established — the event fetch failed, or the item's history has
+ * no record of the label going on. Callers must read null as "leave the label
+ * alone": with no start of the waiting period there is nothing to measure a
+ * response against.
+ *
+ * Only the newest labeling counts. An item can be parked, answered, and parked
+ * again, and each round has to be answered on its own; the reply that cleared the
+ * first round must not clear the second.
+ */
+async function waitingLabelAddedAt({github, owner, repo}, item) {
+  let addedAt = null;
+  try {
+    const events = await github.paginate(github.rest.issues.listEvents, {
+      owner,
+      repo,
+      issue_number: item.number,
+      per_page: 100,
+    });
+    for (const event of events) {
+      if (event.event !== 'labeled' || event.label?.name !== WAITING_LABEL) continue;
+      if (!addedAt || event.created_at > addedAt) {
+        addedAt = event.created_at;
+      }
+    }
+  } catch (error) {
+    console.error(`Failed to fetch label events for #${item.number}:`, error);
+    return null;
+  }
+
+  if (!addedAt) {
+    console.log(`No '${WAITING_LABEL}' labeling recorded on ${item.html_url}; keeping the label.`);
+  }
+  return addedAt;
+}
+
 export default async function issueTriage({github, context}) {
   console.log('A2UI triage-flag reconciliation started');
 
@@ -242,54 +315,70 @@ export default async function issueTriage({github, context}) {
   });
 
   // Fetch each item's contributions in bounded concurrent batches to avoid a
-  // slow serial loop without flooding the API.
-  const itemsWithContributions = await mapInBatches(openItems, async item => ({
-    item,
-    contributions: await fetchContributions({github, owner, repo}, item),
-  }));
+  // slow serial loop without flooding the API. The label's event history is only
+  // needed for the items actually parked on their author, so it costs an extra
+  // call on those alone.
+  const itemsWithContributions = await mapInBatches(openItems, async item => {
+    const client = {github, owner, repo};
+    const [contributions, waitingSince] = await Promise.all([
+      fetchContributions(client, item),
+      labelNames(item).includes(WAITING_LABEL) ? waitingLabelAddedAt(client, item) : null,
+    ]);
+    return {item, contributions, waitingSince};
+  });
 
   // 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
+  // whose labels need 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.
+  // changed a 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));
+    .map(({item, contributions, waitingSince}) => {
+      const labels = labelNames(item);
+      const clearWaiting =
+        labels.includes(WAITING_LABEL) && authorHasResponded(item, contributions, waitingSince);
+
+      // 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(itemsToUpdate, async ({item, reason}) => {
+  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,
-      });
-      const hasFlag = labelNames(fresh).includes(FLAG_LABEL);
-      if (wantsFlag === hasFlag) {
-        return; // Another run already reconciled this item.
+      // 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);
+
+      if (clearWaiting && freshLabels.includes(WAITING_LABEL)) {
+        await github.rest.issues.removeLabel({...target, name: WAITING_LABEL});
+        waitingCleared += 1;
+        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) {
-        await github.rest.issues.addLabels({
-          owner,
-          repo,
-          issue_number: item.number,
-          labels: [FLAG_LABEL],
-        });
+        await github.rest.issues.addLabels({...target, 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,
-        });
+        await github.rest.issues.removeLabel({...target, name: FLAG_LABEL});
         removed += 1;
         console.log(`Unflagged ${item.html_url} — no longer matches any triage rule.`);
       }
@@ -299,7 +388,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 8bb50597ab..302ba02098 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,6 +57,7 @@ const pr = (overrides = {}) =>
     ...overrides,
   });
 
+// Raw comment payload, in the shape the GitHub endpoints return it.
 const comment = (overrides = {}) => ({
   created_at: daysAgo(0),
   author_association: 'MEMBER',
@@ -63,15 +65,29 @@ const comment = (overrides = {}) => ({
   ...overrides,
 });
 
+const RAW_COMMENT_KEYS = Object.keys(comment());
+
+// The normalized event `fetchContributions` produces, which `flagReason` and
+// 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};
+};
+
 describe('isBot', () => {
   it('detects bots by account type and login suffix', () => {
     assert.equal(isBot({type: 'Bot', login: 'whatever'}), true);
     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), true);
+    assert.equal(isBot(null), false);
   });
 });
 
@@ -86,8 +102,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));
   });
@@ -95,13 +111,60 @@ 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 reporter = {login: 'reporter', type: 'User'};
+  const item = issue({created_at: daysAgo(10), user: reporter});
+
+  // The label went on 3 days ago, so only contributions newer than that answer it.
+  const LABELED_AT = daysAgo(3);
+  const authorReply = age => event({created_at: daysAgo(age), user: reporter});
+
+  // Regression: the opening post is by definition the author's and always
+  // predates the label — an item with no replies is the one still waiting, not
+  // one the author has answered.
+  it('does not count the opening post as a response', () => {
+    assert.equal(authorHasResponded(item, [], LABELED_AT), false);
+  });
+
+  it('is true when the author contributed after the label was added', () => {
+    assert.equal(authorHasResponded(item, [authorReply(1)], LABELED_AT), true);
+  });
+
+  it('is false when the author only spoke before the label was added', () => {
+    assert.equal(authorHasResponded(item, [authorReply(5)], LABELED_AT), false);
+  });
+
+  // Ties resolve toward clearing: an item is better off back on the triage queue
+  // than parked and invisible on the strength of a same-second timestamp.
+  it('counts a reply stamped at the moment of labeling', () => {
+    assert.equal(authorHasResponded(item, [authorReply(3)], LABELED_AT), true);
+  });
+
+  it('still counts the author reply when someone else replied after it', () => {
+    const maintainerReply = event({created_at: daysAgo(0), user: {login: 'dev', type: 'User'}});
+    assert.equal(authorHasResponded(item, [authorReply(1), maintainerReply], LABELED_AT), true);
+  });
+
+  it('ignores contributions from everyone but the author', () => {
+    const others = [
+      event({created_at: daysAgo(1), user: {login: 'dev', type: 'User'}}),
+      event({created_at: daysAgo(0), user: {login: 'bot[bot]', type: 'Bot'}}),
+    ];
+    assert.equal(authorHasResponded(item, others, LABELED_AT), false);
+  });
+
+  it('is false when the labeling time is unknown, so the label survives', () => {
+    assert.equal(authorHasResponded(item, [authorReply(1)], null), false);
+  });
+});
+
 describe('flagReason — issues', () => {
   it('flags an issue with no priority label', () => {
     assert.match(flagReason(issue(), [], NOW), /no priority label/);
@@ -193,13 +256,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'},
@@ -235,27 +298,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'},
@@ -266,14 +325,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);
   });
 });
 
@@ -282,7 +334,7 @@ describe('issueTriage reconciliation', () => {
   let calls;
 
   const makeGithub = openItems => {
-    calls = {addLabels: [], removeLabel: [], listComments: [], get: []};
+    calls = {addLabels: [], removeLabel: [], listComments: [], listEvents: [], get: []};
     const rest = {
       issues: {
         listForRepo: 'listForRepo',
@@ -291,6 +343,12 @@ describe('issueTriage reconciliation', () => {
           const item = openItems.find(i => i.number === params.issue_number);
           return {data: item.__comments ?? []};
         }),
+        // Label history, used to find when WAITING_LABEL was added.
+        listEvents: mock.fn(async params => {
+          calls.listEvents.push(params.issue_number);
+          const item = openItems.find(i => i.number === params.issue_number);
+          return {data: item.__events ?? []};
+        }),
         // Live re-read used to guard against concurrent double-labeling.
         // `__fresh` lets a test simulate another run having changed the label.
         get: mock.fn(async params => {
@@ -299,12 +357,20 @@ 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 {
       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;
+      }),
     };
   };
 
@@ -335,7 +401,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);
   });
 
@@ -380,4 +446,124 @@ describe('issueTriage reconciliation', () => {
     await issueTriage({github, context});
     assert.deepEqual(calls.listComments, [12]);
   });
+
+  describe('waiting-for-author-response', () => {
+    const reporter = {login: 'reporter', type: 'User'};
+
+    // Unlike the `flagReason` tests, `issueTriage` measures against the real
+    // clock, so these fixtures are stamped relative to now rather than to NOW.
+    const realDaysAgo = days => new Date(Date.now() - days * DAY).toISOString();
+    const labeling = (name, days) => ({
+      event: 'labeled',
+      label: {name},
+      created_at: realDaysAgo(days),
+    });
+
+    // An item parked on its author: the waiting label went on `labeledDaysAgo`
+    // days ago, and the author has posted `comments` replies `repliedDaysAgo`
+    // days ago. Replies default to now so the staleness rules stay quiet and
+    // each test asserts on the waiting label alone; `labelEvent: false` drops the
+    // labeling from the item's history, as if it could not be read.
+    const parked = (
+      number,
+      {comments = 0, repliedDaysAgo = 0, labeledDaysAgo = 1, labelEvent = true, ...overrides} = {},
+    ) => {
+      const item = issue({number, labels: [WAITING_LABEL], user: reporter, comments, ...overrides});
+      item.__comments = Array.from({length: comments}, () =>
+        comment({
+          created_at: realDaysAgo(repliedDaysAgo),
+          author_association: 'NONE',
+          user: reporter,
+        }),
+      );
+      item.__events = labelEvent ? [labeling(WAITING_LABEL, labeledDaysAgo)] : [];
+      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, 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.listEvents, [16]);
+      assert.deepEqual(calls.removeLabel, [{number: 16, name: WAITING_LABEL}]);
+      assert.equal(calls.addLabels.length, 0);
+    });
+
+    it('keeps the label when the author only spoke before it was added', async () => {
+      // The reply answered an earlier round of the conversation, not this label.
+      github = makeGithub([parked(19, {comments: 1, repliedDaysAgo: 2, labeledDaysAgo: 1})]);
+      await issueTriage({github, context});
+
+      assert.equal(calls.removeLabel.length, 0);
+      assert.equal(calls.addLabels.length, 0); // still parked, so still out of triage
+    });
+
+    it('measures from the most recent labeling, not the first', async () => {
+      // Parked, answered, parked again: the answer to the first round must not
+      // clear the second.
+      const item = parked(20, {comments: 1, repliedDaysAgo: 3});
+      item.__events = [labeling(WAITING_LABEL, 5), labeling(WAITING_LABEL, 1)];
+      github = makeGithub([item]);
+      await issueTriage({github, context});
+
+      assert.equal(calls.removeLabel.length, 0);
+    });
+
+    it('ignores labelings of other labels', async () => {
+      const item = parked(21, {comments: 1, repliedDaysAgo: 2, labeledDaysAgo: 3});
+      item.__events = [labeling(WAITING_LABEL, 3), labeling('P3', 0)];
+      github = makeGithub([item]);
+      await issueTriage({github, context});
+
+      assert.deepEqual(calls.removeLabel, [{number: 21, name: WAITING_LABEL}]);
+    });
+
+    it('keeps the label when its history does not record it being added', async () => {
+      // Nothing to measure the reply against, so leave it for a human.
+      github = makeGithub([parked(22, {comments: 1, labelEvent: false})]);
+      await issueTriage({github, context});
+
+      assert.equal(calls.removeLabel.length, 0);
+      assert.equal(calls.addLabels.length, 0);
+    });
+
+    it('does not read label history for items that are not parked', async () => {
+      github = makeGithub([issue({number: 23})]);
+      await issueTriage({github, context});
+
+      assert.equal(calls.listEvents.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);
+    });
+  });
 });