diff --git a/README.md b/README.md
index dad1c12..9d4e46c 100644
--- a/README.md
+++ b/README.md
@@ -580,7 +580,8 @@ per-repo `noise.additionalIgnores`.
   "noise": { "additionalIgnores": ["packages/*/build/**"] },
   "review": { "trigger": "all",               // which PRs `ecr ci` reviews: "all"
               "label": "ai-review",            // (default, except ai-review:skip) or
-              "skipLabel": "ai-review:skip" }, // "label" (only labeled PRs)
+              "skipLabel": "ai-review:skip",   // "label" (only labeled PRs)
+              "readyForHumanLabel": "ready for human" }, // optional, see below
   "breakGlass": { "marker": "/skip-review" }, // PR body marker that skips the review
   "commentTag": "expo-ai-code-reviewer",      // hidden tag used to find/update the comment
   "auth": { "providers": {
@@ -588,6 +589,58 @@ per-repo `noise.additionalIgnores`.
 }
 ```
 
+`review.readyForHumanLabel` (off by default) names a label that `ecr ci`,
+`ecr post-review` and `ecr review --pr <n> --post` add to the PR when the review
+is ready for a human: the decision is "Ready for human review", with or without
+comments, and the run reviewed the whole PR. These runs get no label:
+
+- A partial run: `--agents` (so `/review <agents>` too), `--scopes`, or a review
+  saved with `ecr review --pr <n> --save-review --agents <ids>` and
+  posted with `ecr post-review`. A bare `/review`, where the router picks the agents, is a
+  full run.
+- A run where a pass did not finish.
+- A run where no reviewer applied, because no changed file matches any agent's
+  `paths`.
+- A routed run with a changed file that no scope matches. With a routing
+  manifest that has no `**/*` catch-all scope, a PR that touches a file outside
+  every scope never gets the label.
+
+A run that gets no label, a `/skip-review` that `ecr ci` acts on, or a run that
+deletes the review comment removes the label, but only when the reviewer added
+it last. Nothing else changes the label, so a ready label added before a push
+stays until the next review posts.
+
+- `ecr post-review` and `ecr review --pr <n> --post` post nothing on a PR with
+  `/skip-review`, and `ecr ci` does nothing on a PR its trigger policy skips (such
+  as one labeled `review.skipLabel`). Both leave the review comment and the label
+  as they are.
+- The reviewer recognises its labels by login, from the label's newest
+  `labeled` or `unlabeled` event on the PR. It removes the label only when its
+  own login added it last, and does not add it again when another login removed
+  it last. Its login is `gh api user`, or, when that fails under GitHub Actions,
+  `github-actions[bot]`, the login of the default `GITHUB_TOKEN`. So:
+  - With a personal token, that person's own removals count as the reviewer's,
+    and the next ready review adds the label again.
+  - Under the default `GITHUB_TOKEN`, other workflows' label changes are
+    `github-actions[bot]` too, and count as the reviewer's.
+  - A local `ecr review --pr <n> --post` and CI use different logins, so neither
+    removes a label the other added.
+  - A GitHub App token cannot read `gh api user`, and its login is not
+    `github-actions[bot]`, so the reviewer never removes the label it added (nor
+    recognises its own review comment).
+  - On a PR with 3,000 events or more, the reviewer cannot tell who changed the
+    label last, and leaves it as it is.
+- It works in the single comment mode. Per-scope comments have no one decision
+  for the PR, so that mode sets no label.
+- `/dismiss` does not change the decision, so it does not change the label.
+- When the reviewer fails before it can load the config, it leaves the label as
+  it is.
+- The decision comes from a model that reads untrusted PR content, so a prompt
+  injection can earn the label. Never use it as a merge gate or in branch
+  protection.
+- The label must differ from `review.label`, `review.skipLabel` and every
+  `<label>:<agent>` label. The workflow token needs `issues: write`.
+
 </details>
 
 <details>
diff --git a/llp/0008-sources-and-reporters.explainer.md b/llp/0008-sources-and-reporters.explainer.md
index 6eb87a1..1a8bdb1 100644
--- a/llp/0008-sources-and-reporters.explainer.md
+++ b/llp/0008-sources-and-reporters.explainer.md
@@ -81,6 +81,14 @@ The reporter maintains exactly one PR comment, plus optional inline threads (see
 
 **Links fail soft.** `linkContextAsync` can be prebuilt and injected once so a CI fan-out builds one diff-lines + base-SHA context for all scopes instead of one pair of `gh` calls per scope — the reporter-side mirror of `memoizeSource` [observed] ([github.ts:33-37, 200-205](../src/reporters/github.ts)). Both underlying fetches fail soft: a missing diff index degrades in-diff findings to plain-text `file:line`, a missing base SHA degrades out-of-diff findings the same way — never a dead link, never a hard failure of the whole report [observed] ([github.ts:194-235](../src/reporters/github.ts); commits f9fecd5, 9446b42). This follows the repo rule that `ecr ci` must never fail a PR's checks on reviewer error [observed] (AGENTS.md: "`ecr ci` must never fail a PR's checks — reviewer errors degrade gracefully").
 
+**The ready label follows the decision, and the bot removes only its own.** With `review.readyForHumanLabel` set, `report` and `reportAggregate` call `syncReadyLabel` after the comment is posted, and `postSkipNote` and `clear` call it with "not ready". `postSkipNote` is `ecr ci`'s break-glass path only: `ecr post-review` and `ecr review --pr --post` post nothing on break-glass, and a PR the trigger policy skips returns before any reporter call, so those leave the comment and the label as they are. Nothing else touches the label, so a label added before a push stays until the next review posts. Label failures only log: the comment is already up [observed] ([github.ts](../src/reporters/github.ts) `syncReadyLabel`, `readyForHuman`, `lastLabelEvent`; tests `src/__tests__/ready-label.test.ts`).
+
+**Ready means the run reviewed the whole PR.** `readyForHuman` is true when every review completed with full coverage (`incomplete` is empty), at least one reviewer applied, and the worst decision is `approve` or `approve_with_comments`; `reportAggregate` also requires no unmatched files. A review where no agent's `paths` matches approves with every `agentSummaries` row `notRun`, so that is what "no reviewer applied" checks; `incomplete` stays empty there, and a noise-only review has no rows at all. A run that reviewed part of the PR sets the reporter's `partialReview`, and then `syncReadyLabel` treats it as not ready: an explicit `--agents` subset in `ecr ci` and `ecr review --pr --post`, a `--scopes` run, whose other scopes come from the comment's stored state without a check against the head, and a deferred review saved with `--agents`, which records `partialReview` in the artifact for `ecr post-review` to pass on. A bare `/review` lets the router pick agents and is a full run. Without `--scopes` every active scope gets a result, failures included, so no other check for missing scopes is needed ([ci.ts](../src/commands/ci.ts) `runLegacyCi`, `runRoutedCi`; [deferred-review.ts](../src/core/deferred-review.ts)).
+
+**Ownership comes from the label's own history.** The newest `labeled` or `unlabeled` event for the label (`lastLabelEvent`; the events API lists the oldest first) decides what is ours: a review that is not ready removes the label only when the newest event is our account's `labeled`, and a ready review does not add it again when the newest event is another account's `unlabeled`. No extra state is stored in the comment. The walk stops at the page cap; when it stops on a full page, a newer event may lie beyond it, so `syncReadyLabel` changes nothing and logs. "Our account" is `resolveOwnLogin`: `gh api user`, or `github-actions[bot]` for the default `GITHUB_TOKEN`. The check is by login, not by person: a personal token treats that person's own changes as ours, under the default token other workflows' label changes are `github-actions[bot]` too and count as ours, and a local `ecr review --pr --post` and CI run as different logins, so neither removes the other's label. A GitHub App token cannot read `/user`, so under Actions `resolveOwnLogin` falls back to `github-actions[bot]`, while the App's actor is expected to be `<app>[bot]` [not verified]: such a setup never removes the label it added, nor recognises its own comment.
+
+**Only the single comment labels, and the label is advisory.** In per-scope mode there is no one decision for the PR, `ecr ci` logs that it sets no label, and the root-tag `clear` of a mode switch removes ours (`runRoutedCi` in [ci.ts](../src/commands/ci.ts)). `/dismiss` re-renders with the stored decision, so it does not change the label. Label names match case-insensitively, as GitHub treats them, and the config check rejects a label that is, in any case, also `review.label`, `review.skipLabel` or a `<label>:<agent>` trigger. The decision comes from model output on untrusted PR content (see [LLP 0001](./0001-trust-model.principles.md)), so the label is advisory, never a merge gate.
+
 ## Inline Threads
 
 With `inline.enabled`, `syncInline` converges one inline thread per in-diff finding: `planInlineSync` decides which threads to create, patch, stub or delete, and the executor runs the plan [observed] ([github.ts](../src/reporters/github.ts) `planInlineSync`, `syncInline`).
diff --git a/src/__tests__/deferred-review.test.ts b/src/__tests__/deferred-review.test.ts
index 61b2dbf..ff6764e 100644
--- a/src/__tests__/deferred-review.test.ts
+++ b/src/__tests__/deferred-review.test.ts
@@ -40,6 +40,7 @@ function config(configDir: string, overrides: Partial<LoadedConfig> = {}): Loade
       protectedCategories: ["security", "secrets"],
       maxAdjudications: 10,
     },
+    review: { trigger: "all", label: "ai-review", skipLabel: "ai-review:skip" },
     ...overrides,
   } as LoadedConfig;
 }
@@ -85,6 +86,21 @@ test("writes and reads an owner-only exact review artifact", async () => {
   expect(JSON.parse(await readFile(saved, "utf8"))).toEqual(parsed);
 });
 
+test("records a review saved from an agent subset as partial; older artifacts still parse", async () => {
+  const root = await tempRoot();
+  const loaded = config(path.join(root, ".expo-code-review"));
+  const saved = await writeDeferredReviewArtifact(loaded, {
+    repo: "expo/expo",
+    pr: 48557,
+    headSha: "a".repeat(40),
+    review: artifact().review,
+    partialReview: true,
+  });
+  expect((await readDeferredReviewArtifact(saved)).partialReview).toBe(true);
+  // artifact() has no partialReview field, as every artifact saved before it existed.
+  expect(artifact().partialReview).toBeUndefined();
+});
+
 test("strictly rejects malformed, oversized, and extended artifacts", async () => {
   const root = await tempRoot();
   const malformed = path.join(root, "malformed.json");
@@ -144,6 +160,11 @@ test("posting config fingerprint covers every comment-policy input", () => {
   expect(
     reviewPostingConfigFingerprint(config(root, { feedback: { ...base.feedback, mode: "off" } })),
   ).not.toBe(fingerprint);
+  expect(
+    reviewPostingConfigFingerprint(
+      config(root, { review: { ...base.review, readyForHumanLabel: "ready for human" } }),
+    ),
+  ).not.toBe(fingerprint);
 });
 
 test("post-review argv requires an explicit artifact, repo, and safe PR", () => {
diff --git a/src/__tests__/ready-label.test.ts b/src/__tests__/ready-label.test.ts
new file mode 100644
index 0000000..f1d8961
--- /dev/null
+++ b/src/__tests__/ready-label.test.ts
@@ -0,0 +1,440 @@
+import { test, expect, afterEach, beforeEach } from "bun:test";
+import { chmod, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path, { delimiter } from "node:path";
+
+import { resetTrustedToolCache } from "../core/exec.js";
+import { ReviewConfigSchema } from "../config/schema.js";
+import type { CoordinatorOutput } from "../core/schema.js";
+import { GitHubReporter, readyForHuman } from "../reporters/github.js";
+
+const TAG = "expo-ai-code-reviewer";
+const LABEL = "ready for human";
+
+const review = (over: Partial<CoordinatorOutput> = {}): CoordinatorOutput => ({
+  decision: "approve",
+  findings: [],
+  summary: "s",
+  incomplete: [],
+  ...over,
+});
+
+test("readyForHuman: both 'Ready for human review' decisions, every review complete", () => {
+  expect(readyForHuman([review()])).toBe(true);
+  expect(readyForHuman([review({ decision: "approve_with_comments" })])).toBe(true);
+  expect(readyForHuman([review({ decision: "request_changes" })])).toBe(false);
+  expect(readyForHuman([review({ couldNotComplete: true })])).toBe(false);
+  // Partial coverage: a pass timed out, so the review may have missed something.
+  expect(readyForHuman([review({ incomplete: ["security timed out"] })])).toBe(false);
+  // An aggregate is as ready as its worst scope.
+  expect(readyForHuman([review(), review({ decision: "request_changes" })])).toBe(false);
+  expect(readyForHuman([review(), review({ couldNotComplete: true })])).toBe(false);
+  expect(readyForHuman([])).toBe(false);
+});
+
+test("readyForHuman: a review where no reviewer applied is not ready; a noise-only one is", () => {
+  const noReviewer = review({
+    agentSummaries: [
+      { agent: "ios", notRun: "paths" },
+      { agent: "web", notRun: "paths" },
+    ],
+  });
+  expect(readyForHuman([noReviewer])).toBe(false);
+  expect(
+    readyForHuman([
+      review({
+        agentSummaries: [
+          { agent: "ios", notRun: "paths" },
+          { agent: "correctness", summary: "Looks fine." },
+        ],
+      }),
+    ]),
+  ).toBe(true);
+  // Noise filtering left nothing to review, so there are no summary rows.
+  expect(readyForHuman([review({ summary: "No reviewable changes after noise filtering." })])).toBe(
+    true,
+  );
+});
+
+test("config: review.readyForHumanLabel is optional and never empty", () => {
+  expect(ReviewConfigSchema.parse({}).review.readyForHumanLabel).toBeUndefined();
+  expect(
+    ReviewConfigSchema.parse({ review: { readyForHumanLabel: LABEL } }).review.readyForHumanLabel,
+  ).toBe(LABEL);
+  expect(ReviewConfigSchema.safeParse({ review: { readyForHumanLabel: "" } }).success).toBe(false);
+  // It must not act as a trigger label.
+  // Label names are unique regardless of case, so a case variant is the same label.
+  for (const readyForHumanLabel of [
+    "ai-review",
+    "ai-review:ready",
+    "ai-review:skip",
+    "AI-Review",
+    "AI-Review:Ready",
+    "AI-Review:Skip",
+  ]) {
+    expect(ReviewConfigSchema.safeParse({ review: { readyForHumanLabel } }).success).toBe(false);
+  }
+  expect(
+    ReviewConfigSchema.safeParse({
+      review: { label: "review-me", readyForHumanLabel: "ai-review" },
+    }).success,
+  ).toBe(true);
+});
+
+// ---- the reporter adds and removes the label through a fake `gh` on PATH ----
+
+// A fake `gh` that logs each call. The PR's labels come from labels.json, and page N
+// of its issue events from events-N.json. FAKE_GH_LABEL_ERROR makes every label call
+// fail, and FAKE_GH_USER_ERROR makes `gh api user` fail.
+const FAKE_GH = `#!/bin/sh
+printf '%s\\n' "$*" >> "$FAKE_GH_DIR/calls.log"
+case "$*" in
+  *"/labels"*)
+    if [ -n "$FAKE_GH_LABEL_ERROR" ]; then echo "$FAKE_GH_LABEL_ERROR" >&2; exit 1; fi
+    case "$*" in
+      *"-X GET "*) if [ -f "$FAKE_GH_DIR/labels.json" ]; then cat "$FAKE_GH_DIR/labels.json"; else printf '[]'; fi ;;
+      *) printf '[]' ;;
+    esac ;;
+  *"/events"*)
+    page=$(printf '%s' "$*" | sed -n 's/.*page=\\([0-9]*\\).*/\\1/p')
+    if [ -f "$FAKE_GH_DIR/events-$page.json" ]; then cat "$FAKE_GH_DIR/events-$page.json"; else printf '[]'; fi ;;
+  "api user"*)
+    if [ -n "$FAKE_GH_USER_ERROR" ]; then echo "HTTP 403" >&2; exit 1; fi
+    printf 'ecr-bot\\n' ;;
+  *"-X GET "*"/comments"*) printf '[]' ;;
+  *"-X POST "*"/comments --input "*) printf '{"id": 1}' ;;
+  *) echo "unexpected gh call: $*" >&2; exit 1 ;;
+esac
+`;
+
+let dir = "";
+const saved: Record<string, string | undefined> = {};
+
+beforeEach(async () => {
+  dir = await mkdtemp(path.join(tmpdir(), "ecr-ready-label-"));
+  await writeFile(path.join(dir, "gh"), FAKE_GH, "utf8");
+  await chmod(path.join(dir, "gh"), 0o755);
+  await writeFile(path.join(dir, "calls.log"), "", "utf8");
+  for (const name of [
+    "PATH",
+    "FAKE_GH_DIR",
+    "FAKE_GH_LABEL_ERROR",
+    "FAKE_GH_USER_ERROR",
+    "GITHUB_ACTIONS",
+  ]) {
+    saved[name] = process.env[name];
+  }
+  process.env.PATH = `${dir}${delimiter}${saved.PATH ?? ""}`;
+  process.env.FAKE_GH_DIR = dir;
+  delete process.env.FAKE_GH_LABEL_ERROR;
+  delete process.env.FAKE_GH_USER_ERROR;
+  delete process.env.GITHUB_ACTIONS;
+  resetTrustedToolCache();
+});
+
+afterEach(async () => {
+  for (const [name, value] of Object.entries(saved)) {
+    if (value === undefined) {
+      delete process.env[name];
+    } else {
+      process.env[name] = value;
+    }
+  }
+  resetTrustedToolCache();
+  await rm(dir, { recursive: true, force: true });
+});
+
+type LabelEvent = { event: "labeled" | "unlabeled"; actor: string; label?: string };
+
+async function fixture(opts: { labels?: string[]; events?: LabelEvent[][] }): Promise<void> {
+  await writeFile(
+    path.join(dir, "labels.json"),
+    JSON.stringify((opts.labels ?? []).map((name) => ({ name }))),
+    "utf8",
+  );
+  for (const [index, page] of (opts.events ?? []).entries()) {
+    await writeFile(
+      path.join(dir, `events-${index + 1}.json`),
+      JSON.stringify(
+        page.map(({ event, actor, label }) => ({
+          event,
+          label: { name: label ?? LABEL },
+          actor: { login: actor },
+        })),
+      ),
+      "utf8",
+    );
+  }
+}
+
+// Each test uses its own PR number: the reporter caches some reads per PR.
+function reporterFor(
+  prNumber: number,
+  opts: {
+    readyForHumanLabel?: string | null;
+    ownLogin?: string | null;
+    partialReview?: boolean;
+  } = {},
+): GitHubReporter {
+  return new GitHubReporter({
+    prNumber,
+    repo: "o/r",
+    commentTag: TAG,
+    ...(opts.ownLogin === null ? {} : { ownLogin: opts.ownLogin ?? "ecr-bot" }),
+    linkContext: { repo: "o/r", prNumber },
+    ...(opts.readyForHumanLabel === null
+      ? {}
+      : { readyForHumanLabel: opts.readyForHumanLabel ?? LABEL }),
+    ...(opts.partialReview ? { partialReview: true } : {}),
+  });
+}
+
+async function captureStderr(run: () => Promise<void>): Promise<string> {
+  const original = process.stderr.write;
+  const chunks: string[] = [];
+  process.stderr.write = ((chunk: unknown) => {
+    chunks.push(String(chunk));
+    return true;
+  }) as typeof process.stderr.write;
+  try {
+    await run();
+  } finally {
+    process.stderr.write = original;
+  }
+  return chunks.join("");
+}
+
+async function calls(): Promise<string[]> {
+  return (await readFile(path.join(dir, "calls.log"), "utf8")).trim().split("\n");
+}
+
+async function post(
+  prNumber: number,
+  posted: CoordinatorOutput,
+  opts: { labels?: string[]; labeledBy?: string; readyForHumanLabel?: string | null } = {},
+): Promise<string[]> {
+  await fixture({
+    ...(opts.labels ? { labels: opts.labels } : {}),
+    ...(opts.labeledBy
+      ? {
+          events: [
+            [
+              { event: "labeled", actor: "someone-else" },
+              { event: "unlabeled", actor: "someone-else" },
+              { event: "labeled", actor: opts.labeledBy },
+            ],
+          ],
+        }
+      : {}),
+  });
+  await reporterFor(prNumber, { readyForHumanLabel: opts.readyForHumanLabel }).report(posted);
+  return calls();
+}
+
+const labelCalls = (calls: string[]): string[] =>
+  calls.filter((call) => call.includes("/labels") && !call.includes("-X GET"));
+
+test("report: a ready review adds the label", async () => {
+  const calls = await post(901, review({ decision: "approve_with_comments" }));
+  expect(labelCalls(calls)).toEqual([
+    `api -X POST repos/o/r/issues/901/labels -f labels[]=${LABEL}`,
+  ]);
+});
+
+test("report: a ready review leaves a label that is already there", async () => {
+  const calls = await post(902, review(), { labels: [LABEL] });
+  expect(labelCalls(calls)).toEqual([]);
+});
+
+test("report: a review that requests changes removes the label the bot added", async () => {
+  const calls = await post(903, review({ decision: "request_changes" }), {
+    labels: [LABEL],
+    labeledBy: "ecr-bot",
+  });
+  expect(labelCalls(calls)).toEqual([
+    "api -X DELETE repos/o/r/issues/903/labels/ready%20for%20human",
+  ]);
+});
+
+test("report: a failed review keeps a label that a person added", async () => {
+  const calls = await post(904, review({ couldNotComplete: true }), {
+    labels: [LABEL],
+    labeledBy: "a-maintainer",
+  });
+  expect(labelCalls(calls)).toEqual([]);
+});
+
+test("report: without the option, no label is read or changed", async () => {
+  const calls = await post(905, review(), { readyForHumanLabel: null });
+  expect(calls.filter((call) => call.includes("/labels") || call.includes("/events"))).toEqual([]);
+});
+
+test("report: a label failure does not fail the report", async () => {
+  process.env.FAKE_GH_LABEL_ERROR = "HTTP 403";
+  const calls = await post(906, review());
+  // The comment was posted before the label call.
+  expect(calls.some((call) => call.includes("-X POST repos/o/r/issues/906/comments"))).toBe(true);
+});
+
+test("reportAggregate: the worst scope decides, so one scope that requests changes removes it", async () => {
+  await fixture({ labels: [LABEL], events: [[{ event: "labeled", actor: "ecr-bot" }]] });
+  await reporterFor(907).reportAggregate(
+    [
+      { scope: "ios", isDefault: false, review: review() },
+      { scope: "web", isDefault: false, review: review({ decision: "request_changes" }) },
+    ],
+    [],
+  );
+  expect(labelCalls(await calls())).toEqual([
+    "api -X DELETE repos/o/r/issues/907/labels/ready%20for%20human",
+  ]);
+});
+
+test("report: a label a person removed is not added again", async () => {
+  await fixture({
+    events: [
+      [
+        { event: "labeled", actor: "ecr-bot" },
+        { event: "unlabeled", actor: "a-maintainer" },
+      ],
+    ],
+  });
+  await reporterFor(908).report(review());
+  expect(labelCalls(await calls())).toEqual([]);
+});
+
+test("report: a label the bot removed is added again when the PR is ready", async () => {
+  await fixture({
+    events: [
+      [
+        { event: "labeled", actor: "ecr-bot" },
+        { event: "unlabeled", actor: "ecr-bot" },
+      ],
+    ],
+  });
+  await reporterFor(909).report(review());
+  expect(labelCalls(await calls())).toEqual([
+    `api -X POST repos/o/r/issues/909/labels -f labels[]=${LABEL}`,
+  ]);
+});
+
+test("report: the newest label event wins across pages of events", async () => {
+  // A person added it on page 1, the bot added it again on page 2.
+  const filler = Array.from({ length: 99 }, () => ({ event: "unlabeled" as const, actor: "x" }));
+  await fixture({
+    labels: [LABEL],
+    events: [
+      [{ event: "labeled", actor: "a-maintainer" }, ...filler],
+      [{ event: "labeled", actor: "ecr-bot" }],
+    ],
+  });
+  await reporterFor(910).report(review({ decision: "request_changes" }));
+  const all = await calls();
+  expect(all.filter((call) => call.includes("/events"))).toHaveLength(2);
+  expect(labelCalls(all)).toEqual([
+    "api -X DELETE repos/o/r/issues/910/labels/ready%20for%20human",
+  ]);
+});
+
+test("report: with no known own login, the label is never removed", async () => {
+  process.env.FAKE_GH_USER_ERROR = "1";
+  await fixture({ labels: [LABEL], events: [[{ event: "labeled", actor: "ecr-bot" }]] });
+  await reporterFor(911, { ownLogin: null }).report(review({ decision: "request_changes" }));
+  expect(labelCalls(await calls())).toEqual([]);
+});
+
+test("report: a label spelled in another case on the PR is the same label", async () => {
+  await fixture({
+    labels: ["Ready For Human"],
+    events: [[{ event: "labeled", actor: "ecr-bot", label: "Ready For Human" }]],
+  });
+  await reporterFor(914).report(review({ decision: "request_changes" }));
+  // DELETE uses the PR's spelling of the label.
+  expect(labelCalls(await calls())).toEqual([
+    "api -X DELETE repos/o/r/issues/914/labels/Ready%20For%20Human",
+  ]);
+});
+
+test("report: a person's removal of the label in another case is respected", async () => {
+  await fixture({
+    events: [
+      [
+        { event: "labeled", actor: "ecr-bot" },
+        { event: "unlabeled", actor: "a-maintainer", label: "Ready For Human" },
+      ],
+    ],
+  });
+  await reporterFor(915).report(review());
+  expect(labelCalls(await calls())).toEqual([]);
+});
+
+test("reportAggregate: unmatched files leave the PR not ready", async () => {
+  await fixture({ labels: [LABEL], events: [[{ event: "labeled", actor: "ecr-bot" }]] });
+  await reporterFor(916).reportAggregate(
+    [{ scope: "ios", isDefault: false, review: review() }],
+    ["scripts/release.sh"],
+  );
+  expect(labelCalls(await calls())).toEqual([
+    "api -X DELETE repos/o/r/issues/916/labels/ready%20for%20human",
+  ]);
+});
+
+test("reportAggregate: a partial run never adds the label", async () => {
+  await fixture({});
+  await reporterFor(917, { partialReview: true }).reportAggregate(
+    [{ scope: "ios", isDefault: false, review: review() }],
+    [],
+  );
+  expect(labelCalls(await calls())).toEqual([]);
+});
+
+test("report: a partial run removes the bot's label even when its review is ready", async () => {
+  await fixture({ labels: [LABEL], events: [[{ event: "labeled", actor: "ecr-bot" }]] });
+  await reporterFor(919, { partialReview: true }).report(review());
+  expect(labelCalls(await calls())).toEqual([
+    "api -X DELETE repos/o/r/issues/919/labels/ready%20for%20human",
+  ]);
+});
+
+test("report: events past the page cap leave the label as it is", async () => {
+  // Every page is full up to the cap, so a newer event may lie beyond it.
+  const page = Array.from({ length: 100 }, () => ({ event: "labeled" as const, actor: "ecr-bot" }));
+  await fixture({ labels: [LABEL], events: Array.from({ length: 30 }, () => page) });
+  const log = await captureStderr(() =>
+    reporterFor(920).report(review({ decision: "request_changes" })),
+  );
+  const all = await calls();
+  expect(all.filter((call) => call.includes("/events"))).toHaveLength(30);
+  expect(labelCalls(all)).toEqual([]);
+  expect(log).toContain("ready label: update skipped");
+});
+
+test("reportAggregate: every scope ready with full coverage adds the label", async () => {
+  await fixture({});
+  await reporterFor(918).reportAggregate(
+    [
+      { scope: "ios", isDefault: false, review: review() },
+      { scope: "web", isDefault: false, review: review({ decision: "approve_with_comments" }) },
+    ],
+    [],
+  );
+  expect(labelCalls(await calls())).toEqual([
+    `api -X POST repos/o/r/issues/918/labels -f labels[]=${LABEL}`,
+  ]);
+});
+
+test("clear: deleting the review comment removes the bot's label", async () => {
+  await fixture({ labels: [LABEL], events: [[{ event: "labeled", actor: "ecr-bot" }]] });
+  await reporterFor(912).clear();
+  expect(labelCalls(await calls())).toEqual([
+    "api -X DELETE repos/o/r/issues/912/labels/ready%20for%20human",
+  ]);
+});
+
+test("postSkipNote: a skipped review removes the bot's label", async () => {
+  await fixture({ labels: [LABEL], events: [[{ event: "labeled", actor: "ecr-bot" }]] });
+  await reporterFor(913).postSkipNote();
+  expect(labelCalls(await calls())).toEqual([
+    "api -X DELETE repos/o/r/issues/913/labels/ready%20for%20human",
+  ]);
+});
diff --git a/src/commands/ci.ts b/src/commands/ci.ts
index 93b02f8..a717cd7 100644
--- a/src/commands/ci.ts
+++ b/src/commands/ci.ts
@@ -565,6 +565,8 @@ async function runLegacyCi(
     cwd,
     feedback: config.feedback,
     inline: config.inline,
+    readyForHumanLabel: config.review.readyForHumanLabel,
+    partialReview: Boolean(agents?.length),
     headSha,
   });
 
@@ -834,6 +836,7 @@ async function runRoutedCi(
     commentTag: rootTag,
     breakGlassMarker: rootConfig.breakGlassMarker,
     cwd,
+    readyForHumanLabel: rootConfig.review.readyForHumanLabel,
   });
   try {
     if (await bgReporter.checkBreakGlass()) {
@@ -888,7 +891,11 @@ async function runRoutedCi(
   const stackWalk = resolveStackWalk(rootConfig.stack, noStackAware);
   const stackConfirm = resolveStackConfirm(rootConfig.stack, noStackAware);
 
-  const reporterFor = (tag: string, withLink = false): GitHubReporter =>
+  const reporterFor = (
+    tag: string,
+    withLink = false,
+    readyForHumanLabel?: string,
+  ): GitHubReporter =>
     new GitHubReporter({
       prNumber,
       repo,
@@ -900,6 +907,10 @@ async function runRoutedCi(
       // no explicit records match replies itself (annotate mode) at report time.
       feedback: rootConfig.feedback,
       inline: rootConfig.inline,
+      readyForHumanLabel,
+      // An agent subset reviews part of every scope; --scopes carries the other
+      // scopes' results over from the comment without checking them against the head.
+      partialReview: Boolean(agents?.length) || Boolean(scopesFilter),
       headSha,
     });
 
@@ -909,7 +920,16 @@ async function runRoutedCi(
   // `fetchAllComments` TTL cache) across the whole run — a fresh reporter per
   // scope would otherwise re-fetch the paginated comment list and re-resolve
   // the bot login once per scope for the identical comment.
-  const singleModeReporter = mode === "single" ? reporterFor(rootTag, true) : undefined;
+  // Only the single comment has one decision for the whole PR, so only it labels.
+  const singleModeReporter =
+    mode === "single"
+      ? reporterFor(rootTag, true, rootConfig.review.readyForHumanLabel)
+      : undefined;
+  if (mode !== "single" && rootConfig.review.readyForHumanLabel) {
+    process.stderr.write(
+      "CI reviewer: review.readyForHumanLabel applies to the single comment mode only; no label is set in per-scope mode.\n",
+    );
+  }
 
   // Per-scope mode has the same property, one comment tag at a time: a scope's feedback
   // seam reads the very comment that scope's review is posted to, so both must use the
@@ -1181,7 +1201,8 @@ async function runRoutedCi(
     // (--scopes) skips this mode-switch cleanup: the root-tag comment may hold the
     // other scopes' aggregate results.
     if (!scopesFilter) {
-      await reporterFor(rootTag).clear();
+      // It also removes a ready label the single comment mode added.
+      await reporterFor(rootTag, false, rootConfig.review.readyForHumanLabel).clear();
     }
     process.stderr.write("CI reviewer: posted per-scope reviews.\n");
   }
diff --git a/src/commands/post-review.ts b/src/commands/post-review.ts
index cde9552..c733861 100644
--- a/src/commands/post-review.ts
+++ b/src/commands/post-review.ts
@@ -148,6 +148,8 @@ export async function postReviewCommand(argv: string[]): Promise<void> {
       cwd,
       feedback: config.feedback,
       inline: config.inline,
+      readyForHumanLabel: config.review.readyForHumanLabel,
+      partialReview: artifact.partialReview,
       headSha,
     });
     const result = await publishDeferredReview(reporter, artifact, async () => {
diff --git a/src/commands/review.ts b/src/commands/review.ts
index 0278196..ce1211e 100644
--- a/src/commands/review.ts
+++ b/src/commands/review.ts
@@ -365,6 +365,8 @@ export async function reviewCommand(argv: string[]): Promise<void> {
             cwd,
             feedback: config.feedback,
             inline: config.inline,
+            readyForHumanLabel: config.review.readyForHumanLabel,
+            partialReview: Boolean(args.agents?.length),
             headSha,
           })
         : null;
@@ -402,6 +404,7 @@ export async function reviewCommand(argv: string[]): Promise<void> {
         headSha,
         review,
         feedback: review.feedback,
+        partialReview: Boolean(args.agents?.length),
       });
       process.stderr.write(`\nSaved postable review artifact: ${artifactPath}\n`);
     }
diff --git a/src/config/schema.ts b/src/config/schema.ts
index 19c3947..6e04d95 100644
--- a/src/config/schema.ts
+++ b/src/config/schema.ts
@@ -160,7 +160,32 @@ export const ReviewConfigSchema = z.object({
       // Opt a single PR out of review. A label (not a config flag) because labels
       // are write-gated to maintainers — a PR author can't add one to dodge review.
       skipLabel: z.string().default("ai-review:skip"),
+      // A label the reviewer adds when a review of the whole PR is ready for a human,
+      // and removes when it is not. Unset (the default) turns labelling off. See the
+      // README.
+      readyForHumanLabel: z.string().min(1).optional(),
     })
+    // The ready label must not act as a trigger label: as `label` (or `label:<agent>`)
+    // it would opt PRs in by itself, and as `skipLabel` the first ready review would
+    // stop every later one. GitHub label names are unique regardless of case, so a
+    // case variant would apply the same label.
+    .refine(
+      (review) => {
+        const ready = review.readyForHumanLabel?.toLowerCase();
+        const label = review.label.toLowerCase();
+        return (
+          ready === undefined ||
+          (ready !== label &&
+            !ready.startsWith(`${label}:`) &&
+            ready !== review.skipLabel.toLowerCase())
+        );
+      },
+      {
+        message:
+          "review.readyForHumanLabel must differ from review.label, review.skipLabel, and every `<label>:<agent>` label",
+        path: ["readyForHumanLabel"],
+      },
+    )
     .default({ trigger: "all", label: "ai-review", skipLabel: "ai-review:skip" }),
   // Stack-aware requalification: walk the OPEN PRs stacked on top of this one and
   // let the coordinator mark absence-style findings a later PR already addresses.
@@ -508,6 +533,7 @@ export interface LoadedConfig {
     trigger: "all" | "label";
     label: string;
     skipLabel: string;
+    readyForHumanLabel?: string;
   };
   /** Root-only stack-aware requalification settings (see ReviewConfigSchema.stack). */
   stack: {
diff --git a/src/core/deferred-review.ts b/src/core/deferred-review.ts
index ef6b69a..be072a4 100644
--- a/src/core/deferred-review.ts
+++ b/src/core/deferred-review.ts
@@ -35,6 +35,8 @@ export const DeferredReviewArtifactSchema = z
     configFingerprint: z.string().regex(/^[0-9a-f]{64}$/i),
     review: CoordinatorOutputSchema,
     feedback: z.array(FeedbackRecordSchema).optional(),
+    /** Saved from an explicit agent subset, so posting it never adds the ready label. */
+    partialReview: z.boolean().optional(),
   })
   .strict();
 
@@ -46,6 +48,7 @@ export interface DeferredReviewInput {
   headSha: string;
   review: CoordinatorOutput;
   feedback?: FeedbackRecord[];
+  partialReview?: boolean;
 }
 
 /** Bind the artifact to the local config fields that affect the posted comment. */
@@ -60,6 +63,8 @@ export function reviewPostingConfigFingerprint(config: LoadedConfig): string {
         // saved review must not post under a different inline policy than it was
         // saved with.
         inline: config.inline,
+        // The ready label is a PR mutation too.
+        readyForHumanLabel: config.review.readyForHumanLabel,
       }),
     )
     .digest("hex");
@@ -87,6 +92,7 @@ export async function writeDeferredReviewArtifact(
     configFingerprint: reviewPostingConfigFingerprint(config),
     review: input.review,
     ...(input.feedback ? { feedback: input.feedback } : {}),
+    ...(input.partialReview ? { partialReview: true } : {}),
   });
   const serialized = `${JSON.stringify(artifact, null, 2)}\n`;
   const serializedBytes = Buffer.byteLength(serialized);
diff --git a/src/reporters/github.ts b/src/reporters/github.ts
index 263921c..1838878 100644
--- a/src/reporters/github.ts
+++ b/src/reporters/github.ts
@@ -16,6 +16,7 @@ import {
   renderAggregateMarkdown,
   renderInlineCommentBody,
   renderMarkdown,
+  worstDecision,
 } from "../core/render.js";
 import type { LinkContext, ReviewState, ScopeReviewResult } from "../core/render.js";
 import { matchReplies } from "../core/responses.js";
@@ -71,6 +72,17 @@ export interface GitHubReporterOptions {
    * tag's inline comments so a comment-mode switch or a disable cleans up.
    */
   inline?: LoadedConfig["inline"];
+  /**
+   * `review.readyForHumanLabel`: the label to add when a posted review is ready for a
+   * human (see readyForHuman), and to remove when it is not. Unset ⇒ no labels.
+   */
+  readyForHumanLabel?: string;
+  /**
+   * This run did not review the whole PR (an explicit agent subset, or a `--scopes`
+   * run that carries the other scopes' results over from the prior comment), so its
+   * decision cannot clear the PR for a human: the ready label is only ever removed.
+   */
+  partialReview?: boolean;
   /**
    * The head commit this run reviews (the PR's immutable head OID, from the source's
    * metadata). Feedback merging binds a stored verdict to the source it judged, so a
@@ -397,6 +409,29 @@ function withInlineUrls(link: LinkContext, inlineUrls: Map<string, string>): Lin
   return inlineUrls.size > 0 ? { ...link, inlineUrls } : link;
 }
 
+/**
+ * Whether a posted review is ready for a human: every review ran with full coverage
+ * (no pass timed out or failed) and at least one reviewer applied, and the decision
+ * (the worst one, for an aggregate) is "Ready for human review", with or without
+ * comments. A review where no agent's `paths` matched approves with every summary row
+ * `notRun`; a noise-only review has no rows and stays ready. Exported for tests.
+ */
+export function readyForHuman(reviews: CoordinatorOutput[]): boolean {
+  return (
+    reviews.length > 0 &&
+    reviews.every(
+      (review) =>
+        review.couldNotComplete !== true &&
+        review.incomplete.length === 0 &&
+        !(
+          review.agentSummaries?.length &&
+          review.agentSummaries.every((row) => row.notRun !== undefined)
+        ),
+    ) &&
+    worstDecision(reviews.map((review) => review.decision)) !== "request_changes"
+  );
+}
+
 // @ref LLP 0011#suppression-is-never-silent [implements] — a verdict carries only while BOTH the reply and the reviewed source are unchanged
 /**
  * Carry a decision already recorded in the prior comment state onto the freshly
@@ -709,6 +744,8 @@ export class GitHubReporter implements Reporter {
     await this.upsertComment(
       `${this.marker}\n🤖 AI review skipped via \`${this.options.breakGlassMarker}\`.`,
     );
+    // A skipped review clears nobody for a human.
+    await this.syncReadyLabel(false);
   }
 
   /**
@@ -758,6 +795,7 @@ export class GitHubReporter implements Reporter {
         state?.mentioned,
       ),
     );
+    await this.syncReadyLabel(readyForHuman([review]));
   }
 
   /**
@@ -767,6 +805,7 @@ export class GitHubReporter implements Reporter {
    * (possibly truncated) embedded state — so the inline sync must not stub/delete
    * threads it merely cannot see. Any failed scope forces the same, since its
    * findings list is empty without being clean.
+   * Unmatched files leave the PR not ready for a human.
    */
   async reportAggregate(
     results: ScopeReviewResult[],
@@ -808,6 +847,9 @@ export class GitHubReporter implements Reporter {
         pins,
       ),
     );
+    await this.syncReadyLabel(
+      unmatchedFiles.length === 0 && readyForHuman(results.map((result) => result.review)),
+    );
   }
 
   /**
@@ -1092,6 +1134,8 @@ export class GitHubReporter implements Reporter {
     for (const comment of await this.ownComments()) {
       await this.deleteComment(comment.id);
     }
+    // With no review comment, no review clears the PR for a human.
+    await this.syncReadyLabel(false);
     // Sweep this tag's inline threads too, gated on the config KEY being present
     // (not on `enabled`), so a comment-mode switch or a later disable still cleans
     // up — while callers that never wire `inline` (break-glass reporter, terminal
@@ -1965,6 +2009,114 @@ export class GitHubReporter implements Reporter {
     );
   }
 
+  // @ref LLP 0008#comment-lifecycle [implements] — the ready label follows the decision; only our own label is removed
+  /**
+   * Add `readyForHumanLabel` when `ready` (and the run is not partial), or remove it
+   * when not. The label's history on the PR decides what is ours: it is removed only
+   * when our account added it last, and it is not added again once another account
+   * removed it. Fail-soft: the review comment is already posted, and a label failure
+   * only logs.
+   */
+  private async syncReadyLabel(decisionReady: boolean): Promise<void> {
+    const label = this.options.readyForHumanLabel;
+    if (!label) {
+      return;
+    }
+    const ready = decisionReady && this.options.partialReview !== true;
+    try {
+      const gh = await resolveTrustedTool("gh");
+      const issue = `repos/${this.options.repo}/issues/${this.options.prNumber}`;
+      const { stdout } = await run(
+        gh,
+        ["api", "-X", "GET", `${issue}/labels`, "-f", "per_page=100"],
+        {
+          cwd: this.options.cwd,
+        },
+      );
+      // Label names are unique regardless of case, so the PR's label may be spelled
+      // differently from the config; DELETE needs the PR's spelling.
+      const current = (JSON.parse(stdout) as Array<{ name?: string }>).find(
+        (entry) => entry.name?.toLowerCase() === label.toLowerCase(),
+      );
+      const present = current?.name !== undefined;
+      if (ready === present) {
+        return;
+      }
+      const [last, ownLogin] = await Promise.all([
+        this.lastLabelEvent(label),
+        this.resolveOwnLogin(),
+      ]);
+      if (last === "undecided") {
+        process.stderr.write(
+          `ready label: update skipped: the PR has more than ${GitHubReporter.MAX_COMMENT_PAGES} pages of events, so whose label it is cannot be told\n`,
+        );
+        return;
+      }
+      const ours = ownLogin != null && last?.actor === ownLogin;
+      if (ready && !(last?.event === "unlabeled" && !ours)) {
+        await run(gh, ["api", "-X", "POST", `${issue}/labels`, "-f", `labels[]=${label}`], {
+          cwd: this.options.cwd,
+        });
+      } else if (!ready && last?.event === "labeled" && ours) {
+        await run(
+          gh,
+          ["api", "-X", "DELETE", `${issue}/labels/${encodeURIComponent(current?.name ?? label)}`],
+          { cwd: this.options.cwd },
+        );
+      }
+    } catch (error) {
+      process.stderr.write(`ready label: update skipped: ${errorMessage(error)}\n`);
+    }
+  }
+
+  /**
+   * The newest `labeled` or `unlabeled` event for `label` (in any case) on this PR, or
+   * null. The events API lists the oldest first, so the last match wins. "undecided"
+   * when the walk stops at the page cap on a full page: newer events may follow.
+   */
+  private async lastLabelEvent(
+    label: string,
+  ): Promise<{ event: "labeled" | "unlabeled"; actor?: string } | null | "undecided"> {
+    const gh = await resolveTrustedTool("gh");
+    let last: { event: "labeled" | "unlabeled"; actor?: string } | null = null;
+    for (let page = 1; page <= GitHubReporter.MAX_COMMENT_PAGES; page++) {
+      const { stdout } = await run(
+        gh,
+        [
+          "api",
+          "-X",
+          "GET",
+          `repos/${this.options.repo}/issues/${this.options.prNumber}/events`,
+          "-f",
+          "per_page=100",
+          "-f",
+          `page=${page}`,
+        ],
+        { cwd: this.options.cwd },
+      );
+      const events = JSON.parse(stdout) as Array<{
+        event?: string;
+        label?: { name?: string };
+        actor?: { login?: string } | null;
+      }>;
+      for (const entry of events) {
+        if (
+          (entry.event === "labeled" || entry.event === "unlabeled") &&
+          entry.label?.name?.toLowerCase() === label.toLowerCase()
+        ) {
+          last = {
+            event: entry.event,
+            ...(entry.actor?.login ? { actor: entry.actor.login } : {}),
+          };
+        }
+      }
+      if (events.length < 100) {
+        return last;
+      }
+    }
+    return "undecided";
+  }
+
   private async deleteComment(commentId: number): Promise<void> {
     this.invalidateComments();
     const gh = await resolveTrustedTool("gh");
diff --git a/templates/config.jsonc b/templates/config.jsonc
index 163dbd3..11ebdd6 100644
--- a/templates/config.jsonc
+++ b/templates/config.jsonc
@@ -68,6 +68,9 @@
   //   "trigger": "label" — review only PRs labeled `label` (or `label:<agent>`).
   // The `skipLabel` is write-gated (only maintainers can add labels), so a PR
   // author can't opt their own PR out.
+  // `readyForHumanLabel` (optional, off by default): a label the reviewer adds when
+  // a review of the whole PR is ready for a human, and removes when it is not.
+  // Never use it as a merge gate. See the README.
   "review": { "trigger": "all", "label": "ai-review", "skipLabel": "ai-review:skip" },
 
   // A maintainer comment containing this marker skips the CI review.