@davidvornholt/standards 0.15.1 → 0.16.0

package/README.md

@@ -35,7 +35,7 @@ standards poller --print-units --config <path>
 
 `structure` enforces the canonical monorepo structure contract: workspace scripts (`check-types`, `lint`, `lint:fix`, `test`), root gate scripts, filtered Turbo convenience aliases, internal `0.0.0`/`workspace:*` versioning, package `exports`, shared tsconfig inheritance, and browser a11y wiring. Only a workspace containing an explicit `*.a11y.ts` suite must provide a `test:a11y` script and direct `@axe-core/playwright` and `@playwright/test` dependencies. `check` includes `structure`, so these rules gate every consumer PR.
 
-`poller` runs one tick of the fix poller: host-level automation that turns maintainer-approved GitHub issues into verified draft PRs and maintainer-approved draft PRs into completed review-fix cycles, using headless Codex runs. All workflow state lives in GitHub labels, comments, and draft PRs (the labels are canonical declared settings — see `github --apply`), so ticks are stateless, re-runnable, and safe to schedule from any host. A tick claims work by label (`fix-in-progress` / `review-in-progress`), releases claims stale for longer than `staleClaimHours`, and fails loudly — a red tick means jobs stalled, never silence. Trust is verified per event, not per configuration: the approval labels (`approved-for-fix`, `approved-for-review`) only count when the applying user holds the `admin` or `maintain` role, bind to the exact approved issue revision or PR head, and are revalidated before publication; only admin/maintain comments are treated as answers to agent questions. The poller removes its direct GitHub token variables before launching Codex, but the approved run shares the host service identity and can read its other ambient credentials and logged-in tool state; that accepted visibility must not be treated as credential isolation. The run works in a throwaway git worktree, grants Codex write access to that worktree and its exact Git common directory so commits can update the linked repository metadata, hands results back through a structured outcome file, and then verifies effects (commits exist, no protected paths touched) before pushing, opening the draft PR, or posting the review — the required CI checks on the resulting PR remain the quality gate. Host mutation is declarative-only: `--print-units` emits a correctly escaped systemd service and timer for the polling host's infrastructure repository to adapt and deploy. That repository owns the service identity, writable HOME, PATH, GitHub token environment, lingering, and deployment. The service's tick budget (`TimeoutStartSec`) is derived from `maxJobsPerTick` × `runTimeoutMinutes` plus overhead, so re-render and redeploy the units after changing either value.
+`poller` runs one tick of the fix poller: host-level automation that turns maintainer-approved GitHub issues into verified draft PRs and maintainer-approved draft PRs into completed review-fix cycles, using headless Codex runs. All workflow state lives in GitHub labels, comments, and draft PRs (the labels are canonical declared settings — see `github --apply`), so ticks are stateless, re-runnable, and safe to schedule from any host. A tick claims work by label (`fix-in-progress` / `review-in-progress`), releases claims stale for longer than `staleClaimHours`, and fails loudly — a red tick means jobs stalled, never silence. A separate acknowledgement tick validates pending approvals and posts one deduplicated queued message per approval generation; it never claims or starts work, so it can keep giving maintainers prompt feedback while the worker is occupied. When a worker claims a request, it posts a concise start message. The exact approval and distributed claim records remain in hidden comment metadata, and losing claim contenders remove their duplicate comments. Trust is verified per event, not per configuration: the approval labels (`approved-for-fix`, `approved-for-review`) only count when the applying user holds the `admin` or `maintain` role, bind to the exact approved issue revision or PR head, and are revalidated before publication; only admin/maintain comments are treated as answers to agent questions. The poller removes its direct GitHub token variables before launching Codex, but the approved run shares the host service identity and can read its other ambient credentials and logged-in tool state; that accepted visibility must not be treated as credential isolation. The run works in a throwaway git worktree, grants Codex write access to that worktree and its exact Git common directory so commits can update the linked repository metadata, hands results back through a structured outcome file, and then verifies effects (commits exist, no protected paths touched) before pushing, opening the draft PR, or posting the review — the required CI checks on the resulting PR remain the quality gate. Host mutation is declarative-only: `--print-units` emits four correctly escaped systemd units for the polling host's infrastructure repository to adapt and deploy: the worker service and timer plus an independent lightweight acknowledgement service and timer. That repository owns the service identity, writable HOME, PATH, GitHub token environment, lingering, and deployment. The worker service's tick budget (`TimeoutStartSec`) is derived from `maxJobsPerTick` × `runTimeoutMinutes` plus overhead, so re-render and redeploy the units after changing either value.
 
 `creds` is the credential broker: it mints scoped Cloudflare tokens, rotates and revokes those tokens, and places GitHub App credentials into SOPS-encrypted targets — secret values never touch stdout, argv, or an agent's context; commands print only metadata (token name, scopes, expiry, destination). Cloudflare reconciliation has exactly two sources of truth: the plaintext key structure of the SOPS files and the provider token list under the deterministic naming scheme `standards/<owner>/<repo>/<sops-target>/<dotted.key>`; there is no separate credential manifest. `plan` and `apply` reconcile Cloudflare only: each run uses the stored bootstrap credential to verify its current provider token ID, excludes that ID from reconciliation regardless of its current name, and aborts if the identity cannot be correlated with the complete account token list; a brokered token whose SOPS key was deleted is revoked, while one nearing expiry (30 days) is renewed by creating a fresh-expiry replacement with the live token's policy, durably writing and verifying the new value, and only then revoking the old token; secrets the broker did not mint are never touched. Without a manifest there is no desired-policy record, so live policy drift is not detected, and a repository rename or transfer changes the deterministic namespace and requires the visible old token to be re-minted under the new name and revoked. `add cloudflare` mints an account-owned API token (default TTL 90 days) scoped to the named permission groups (`permissions` lists the valid names) and writes it to `--dest <target>:<dotted.key>`, where `<target>` resolves like the canonical `just secrets` targets (`ci` → `secrets/ci.yaml`, `prod-1` → `infra/hosts/prod-1/secrets.yaml`); zone-scoped groups such as DNS Write are rejected because the current command supplies an account resource, not a zone resource. `--bucket <name>` switches the policy resource to a single R2 bucket; `--jurisdiction default|eu` selects the provider jurisdiction and defaults to `default`, producing `com.cloudflare.edge.r2.bucket.<account_id>_default_<bucket>` or `com.cloudflare.edge.r2.bucket.<account_id>_eu_<bucket>`. FedRAMP jurisdictions are not supported. Bucket destinations accept only bucket-scoped groups such as Workers R2 Storage Bucket Item Read/Write, and account-scoped groups are rejected. `--s3` requires `--bucket` and stores the S3-compatible credential pair Cloudflare derives from an API token — access key ID is the token ID, secret access key is the SHA-256 hex digest of the token value — as `<dotted.key>.access_key_id` and `<dotted.key>.secret_access_key` under the destination instead of the raw token value; the default endpoint is `https://<account_id>.r2.cloudflarestorage.com`, while EU uses `https://<account_id>.eu.r2.cloudflarestorage.com`. Reconciliation infers each destination's concrete write footprint from the plaintext SOPS key structure — a bearer owns the leaf at its key, while an S3 token owns both pair leaves — and aborts before mutation when managed footprints intersect. `plan` and `apply` renew and revoke S3 destinations like any other brokered token, but renewal first proves the stored access key ID matches the current provider token; an incomplete pair, unreadable value, or identity mismatch is surfaced as a finding and never mutated automatically. `add github` writes the broker GitHub App's `app_id` and `private_key` under the destination key; durable GitHub tokens cannot be created via API (PAT and OAuth-app creation are UI-only), so workflows mint short-lived installation tokens from the App at runtime (`actions/create-github-app-token`), scoped per repository and permission. The canonical weekly sync expects `bun standards creds add github --dest ci:ci.broker_app`, then mints a current-repository token with Contents read and Pull requests write; missing credentials or minting failures stop it without a fallback. Bootstrap is once per machine: `login github` runs the App manifest flow (a localhost page posts the pre-filled manifest; one "Create GitHub App" click; credentials return through the conversion endpoint — nothing is copied by hand) and opens the installation page, where the App must be bound to selected repositories rather than all repositories; `login cloudflare` guides the one dashboard paste Cloudflare requires for the first account token (named `standards-broker` to match the App, created from the "Create additional tokens" token template because its "Account API Tokens: Edit" permission is unavailable in the custom token builder, and holding that permission only), verifies that it is active, correlates its verified ID with the complete account token list and an active list record, and stores it; a bootstrap token named inside the minted `standards/` namespace is rejected before storage to keep its role unambiguous, while any other divergence from the recommended name only warns. `plan` and `apply` do not rotate GitHub App keys; create a replacement key on the App's settings page, atomically replace `github.private_key` in the protected machine-global broker store while preserving its `0600` mode, then update every intended SOPS destination, verify workflows can mint installation tokens, and revoke the old key manually. Root credentials live in the machine-global broker store (see Configuration); SOPS writes go through `sops edit` with a non-interactive editor, preserving comments and reusing the file's data key.
 
@@ -46,7 +46,7 @@ standards poller --print-units --config <path>
 - **`.github/dependabot.local.yml`** (optional) — repo-owned Dependabot extension composed with the canonical `.github/dependabot.base.yml` into the generated `.github/dependabot.yml`. May define `updates` and top-level `registries`; a block matching a canonical normalized target may only add `ignore` and/or `registries` entries. Other matching-block policy is rejected deliberately. A missing or comments-only file means no additions. CLI 0.10.1 requires the selected content ref to contain the canonical base and rejects older refs before mutation.
 - **`sync-standards.local.json`** (optional) — consumer-owned sync policy at the repo root, validated by `doctor`/`check` and every `init`/`sync` even when an explicit ref or local source makes its `"ref"` irrelevant. All fields optional; a missing file means the defaults. `"ref"` is a non-empty single-line string that pins a tag, branch, or full commit sha to sync from instead of `main` (an explicit `--ref` overrides it; a local-path `--from` source is used as-is and ignores only the validated pin). `"autoSync": false` is read by the standards-sync workflow, not the CLI, and skips the weekly scheduled run; deliberate syncs then run locally because the secret-bearing workflow is schedule-only. Version 0.7.0 removes the legacy `STANDARDS_AUTO_SYNC` and `STANDARDS_SYNC_REF` variable behavior; consumers must upgrade the package and lockfile before adopting a policy file.
 - **`.github/settings.local.json` `"rulesetEnforcement": "unavailable-on-plan"`** (optional) — declares that the repository's GitHub plan cannot enforce rulesets (private repositories on GitHub Free, both personal accounts and organizations). `github --check` and `--apply` then skip rulesets instead of comparing them, because a comparison cannot be trusted there: personal accounts answer ruleset reads with HTTP 403, and free-plan organizations report declared rulesets as active while silently not enforcing them. Plan-gated repository settings that only function alongside branch protection (`allow_auto_merge`) are skipped for the same reason — GitHub accepts a PATCH for them with HTTP 200 and silently keeps the old value. The remaining repository merge settings are still checked and converged, and both commands print an unprotected-branch notice on every run. The only accepted value is `"unavailable-on-plan"` (enforcement is the default; omit the key on paid plans), and combining the opt-out with additional local rulesets is rejected. After upgrading the plan, remove the declaration and run `bun standards github --apply` to restore enforcement.
-- **Poller config file** (required for `poller`, passed via `--config`) — host-level JSON, deliberately not repository state. Required: `"repos"` (1–12 unique `owner/repo` strings), `"model"` and `"reasoningEffort"` (passed to `codex exec`; the model choice is deliberate and has no default). The 12-repository maximum keeps the one-minute idle tick's baseline GitHub reads within a 5,000-request/hour API budget while retaining headroom for pagination, active jobs, writes, and other token users. Existing configs above the limit must be reduced or split across pollers with independent GitHub API budgets before upgrading. Optional: `"maxJobsPerTick"` (default 1 — the concurrency and rate-limit guard; subscription-authenticated Codex runs share the interactive rate window), `"staleClaimHours"` (default 6; must exceed `runTimeoutMinutes` so a sweep can never release the claim of a job that is still running), `"runTimeoutMinutes"` (default 240 — the timeout catches wedged agents, not honest multi-hour review runs), `"cacheDir"` (default `~/.cache/standards-poller`; holds bare mirrors and job worktrees; relative paths resolve against the config file), `"extraCodexArgs"` (extra `codex exec` arguments, e.g. enabling the collaboration feature for subagent fan-out). Unknown keys are rejected. The poller needs `git`, `codex` (authenticated — its rotating auth state must live in a writable location), and a GitHub token per the bullet below; the token needs issues, pull-requests, and contents write on the watched repos, and nothing else.
+- **Poller config file** (required for `poller`, passed via `--config`) — host-level JSON, deliberately not repository state. Required: `"repos"` (1–12 unique `owner/repo` strings), `"model"` and `"reasoningEffort"` (passed to `codex exec`; the model choice is deliberate and has no default). The 12-repository maximum and five-minute acknowledgement cooldown keep supported mixed fix/review queues and persisted review-plan recovery below the 5,000-request/hour GitHub API budget with at least 1,400 requests/hour reserved for pagination, active jobs, writes, and other token users; the compound regression bound covers four acknowledged fixes plus four acknowledged reviews with persisted plans in every repository at no more than 3,312 requests/hour. Existing configs above the repository limit must be reduced or split across pollers with independent GitHub API budgets before upgrading. Optional: `"maxJobsPerTick"` (default 1 — the maximum number of new Codex runs the sequential worker may start in one tick), `"staleClaimHours"` (default 6; must exceed `runTimeoutMinutes` so a sweep can never release the claim of a job that is still running), `"runTimeoutMinutes"` (default 240 — the timeout catches wedged agents, not honest multi-hour review runs), `"cacheDir"` (default `~/.cache/standards-poller`; holds bare mirrors and job worktrees; relative paths resolve against the config file), `"extraCodexArgs"` (extra `codex exec` arguments, e.g. enabling the collaboration feature for subagent fan-out). Unknown keys are rejected. The poller needs `git`, `codex` (authenticated — its rotating auth state must live in a writable location), and a GitHub token per the bullet below; the token needs issues, pull-requests, and contents write on the watched repos, and nothing else.
 - **Broker store** (created by `creds login`) — machine-global root credentials at `$XDG_CONFIG_HOME/standards/broker.yaml` (default `~/.config/standards/broker.yaml`; override with `STANDARDS_BROKER_FILE`), holding the GitHub App identity (id, slug, client id, private key) and one bootstrap token per Cloudflare account. The file is plaintext with `0600` permissions — deliberately the same local-account trust boundary as the plaintext personal age identity at `~/.config/sops/age/keys.txt`, which unlocks the same secrets; SOPS-encrypting the store to that adjacent identity would not improve custody. Writes use an owner-only temporary file and atomic replacement, and simultaneous provider logins merge rather than overwrite each other; `creds status` warns when the final mode is broader. The store lives outside every repository, is never synced or backed up, and losing it is cheap: re-run the two login commands and revoke the old App key and bootstrap token. On an additional machine, do not create a second App: generate an additional private key from the existing App's settings page (GitHub Apps support several active keys; key generation has no API) and add it to that machine's store, so retiring a machine revokes one key, not the setup.
 - **`GH_TOKEN` / `GITHUB_TOKEN`** (optional) — GitHub API token for the `github` command and the GitHub portion of `check`. When neither is set, the token from the local `gh` CLI is used; with no token at all, reads still work on public repositories. `--apply` needs an admin token. GitHub's REST API reveals repo merge settings only to write-capable viewers — `check` retries REST-hidden keys over GraphQL, which serves them to read-only tokens — ruleset `bypass_actors` requires repository Administration read, and private-repository labels require Issues read (or Pull requests read); a token that still cannot see declared state fails the check rather than passing unverified. In CI, the canonical workflow decrypts `ci.github_settings_read_token` from the SOPS-encrypted `secrets/ci.yaml`: a repository-scoped fine-grained PAT with read-only "Administration" and "Issues" access.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidvornholt/standards",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "Bootstrap, synchronize, and validate davidvornholt/standards consumers",
   "license": "MIT",
   "repository": {
@@ -78,9 +78,11 @@
     "src/github-settings.ts",
     "src/managed-files.ts",
     "src/poller-approval.ts",
+    "src/poller-acknowledgements.ts",
     "src/poller-claim.ts",
     "src/poller-codex.ts",
     "src/poller-commands.ts",
+    "src/poller-comment-metadata.ts",
     "src/poller-config.ts",
     "src/poller-fix-outcome.ts",
     "src/poller-fix-output.ts",
@@ -97,13 +99,16 @@
     "src/poller-prompts.ts",
     "src/poller-protected-paths.ts",
     "src/poller-protocol.ts",
+    "src/poller-queue-marker.ts",
     "src/poller-review-publication.ts",
+    "src/poller-review-eligibility.ts",
     "src/poller-review-output.ts",
     "src/poller-review-artifacts.ts",
     "src/poller-review-execution.ts",
     "src/poller-review-state.ts",
     "src/poller-review-validation.ts",
     "src/poller-schedule.ts",
+    "src/poller-status.ts",
     "src/poller-review-run.ts",
     "src/poller-tick.ts",
     "src/poller-trust.ts",

package/src/cli.ts

@@ -88,6 +88,7 @@ type CliOptions = {
   readonly profile: StructureProfile;
   readonly config: string | undefined;
   readonly printUnits: boolean;
+  readonly acknowledgeOnly: boolean;
 };
 
 const sha256 = (buf: Buffer): string =>
@@ -755,7 +756,9 @@ Options:
   --apply          With github: converge the live repository (needs admin auth)
   --write          With dependabot: regenerate the composed .github/dependabot.yml
   --config <path>  With poller: the host-level poller config file (required)
-  --print-units    With poller: print declarative systemd unit content without touching the host`;
+  --print-units    With poller: print declarative systemd unit content without touching the host
+  --acknowledge-only
+                   With poller: acknowledge queued requests without starting work`;
 
 const commandFromArg = (arg: string): Command => {
   if (
@@ -811,6 +814,7 @@ type ParsedFlags = {
   readonly profile: StructureProfile | undefined;
   readonly config: string | undefined;
   readonly printUnits: boolean;
+  readonly acknowledgeOnly: boolean;
 };
 
 const assertPollerOptionUsage = (flags: ParsedFlags): void => {
@@ -820,6 +824,14 @@ const assertPollerOptionUsage = (flags: ParsedFlags): void => {
   if (flags.printUnits && flags.command !== 'poller') {
     throw new Error('--print-units is only valid with the poller command');
   }
+  if (flags.acknowledgeOnly && flags.command !== 'poller') {
+    throw new Error('--acknowledge-only is only valid with the poller command');
+  }
+  if (flags.acknowledgeOnly && flags.printUnits) {
+    throw new Error(
+      'poller accepts only one of --acknowledge-only or --print-units',
+    );
+  }
 };
 
 // Every option is only meaningful with specific commands; reject the rest so a
@@ -864,6 +876,7 @@ const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
   let profile: StructureProfile | undefined;
   let config: string | undefined;
   let printUnits = false;
+  let acknowledgeOnly = false;
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
@@ -871,6 +884,9 @@ const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
       case '--apply':
         apply = true;
         break;
+      case '--acknowledge-only':
+        acknowledgeOnly = true;
+        break;
       case '--config':
         config = nextOptionValue(argv, index);
         index += 1;
@@ -921,6 +937,7 @@ const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
     profile,
     config,
     printUnits,
+    acknowledgeOnly,
   });
 
   return {
@@ -934,6 +951,7 @@ const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
     profile: profile ?? 'consumer',
     config,
     printUnits,
+    acknowledgeOnly,
   };
 };
 
@@ -1164,6 +1182,7 @@ const main = async (): Promise<void> => {
     profile,
     config,
     printUnits,
+    acknowledgeOnly,
   } = parseArgs(process.argv.slice(2));
 
   if (command === undefined) {
@@ -1194,7 +1213,13 @@ const main = async (): Promise<void> => {
   }
 
   if (command === 'poller') {
-    if (!(await runPollerCommand({ configPath: config, printUnits }))) {
+    if (
+      !(await runPollerCommand({
+        configPath: config,
+        printUnits,
+        acknowledgeOnly,
+      }))
+    ) {
       process.exitCode = 1;
     }
     return;

package/src/poller-acknowledgements.ts

@@ -0,0 +1,159 @@
+import {
+  issueRevision,
+  prRevision,
+  readApprovalBinding,
+} from './poller-approval';
+import type { PollerConfig } from './poller-config';
+import { type IssueItem, listOpenIssuesWithLabel } from './poller-github';
+import { getPullRequest } from './poller-github-pulls';
+import type { JobDeps } from './poller-job-shared';
+import { APPROVED_FOR_FIX, APPROVED_FOR_REVIEW } from './poller-protocol';
+import {
+  inspectQueuedAcknowledgement,
+  type PollerJobKind,
+} from './poller-queue-marker';
+import { reviewEligibility } from './poller-review-eligibility';
+import { readReviewPlan } from './poller-review-state';
+import { acknowledgeQueuedJob } from './poller-status';
+import type { RoleCache } from './poller-trust';
+
+export type AcknowledgementReport = {
+  readonly lines: ReadonlyArray<string>;
+  readonly problems: ReadonlyArray<string>;
+};
+
+const approvalFor = async (
+  deps: JobDeps,
+  item: IssueItem,
+  kind: PollerJobKind,
+): Promise<Awaited<ReturnType<typeof readApprovalBinding>> | null> => {
+  let target: string;
+  if (kind === 'fix') {
+    target = issueRevision(item);
+    if (
+      await inspectQueuedAcknowledgement({
+        deps,
+        item,
+        kind,
+        target,
+      })
+    ) {
+      return null;
+    }
+  } else {
+    const pr = await getPullRequest(deps.token, deps.repo, item.number);
+    const currentTarget = prRevision(pr.baseRef, pr.baseSha, pr.headSha);
+    if (
+      pr.draft &&
+      pr.headRepo === deps.repo &&
+      (await inspectQueuedAcknowledgement({
+        deps,
+        item,
+        kind,
+        target: currentTarget,
+      }))
+    ) {
+      return null;
+    }
+    const plan = await readReviewPlan(deps, pr);
+    if (
+      reviewEligibility({
+        repo: deps.repo,
+        pr,
+        hasPlan: plan !== null,
+      }).kind !== 'eligible'
+    ) {
+      return null;
+    }
+    target = currentTarget;
+  }
+  return readApprovalBinding(
+    {
+      token: deps.token,
+      repo: deps.repo,
+      issueNumber: item.number,
+    },
+    kind === 'fix' ? APPROVED_FOR_FIX : APPROVED_FOR_REVIEW,
+    target,
+  );
+};
+
+const acknowledgeItems = async (options: {
+  readonly deps: JobDeps;
+  readonly items: ReadonlyArray<IssueItem>;
+  readonly kind: PollerJobKind;
+  readonly lines: Array<string>;
+  readonly problems: Array<string>;
+}): Promise<void> => {
+  const { deps, items, kind, lines, problems } = options;
+  for (const item of items) {
+    try {
+      // biome-ignore lint/performance/noAwaitInLoops: acknowledgement writes are deliberately serialized to avoid GitHub secondary rate limits.
+      const approval = await approvalFor(deps, item, kind);
+      if (
+        approval !== null &&
+        typeof approval !== 'string' &&
+        (await acknowledgeQueuedJob(deps, item.number, approval, kind))
+      ) {
+        lines.push(
+          `${deps.repo} ${kind === 'fix' ? `#${item.number}` : `PR #${item.number}`}: acknowledged as queued`,
+        );
+      }
+    } catch (error) {
+      problems.push(
+        `${deps.repo}#${item.number}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+};
+
+const acknowledgeRepository = async (
+  deps: JobDeps,
+  lines: Array<string>,
+  problems: Array<string>,
+): Promise<void> => {
+  const reviews = (
+    await listOpenIssuesWithLabel(deps.token, deps.repo, APPROVED_FOR_REVIEW)
+  ).filter((item) => item.isPullRequest);
+  const fixes = (
+    await listOpenIssuesWithLabel(deps.token, deps.repo, APPROVED_FOR_FIX)
+  ).filter((item) => !item.isPullRequest);
+  await acknowledgeItems({
+    deps,
+    items: reviews,
+    kind: 'review',
+    lines,
+    problems,
+  });
+  await acknowledgeItems({
+    deps,
+    items: fixes,
+    kind: 'fix',
+    lines,
+    problems,
+  });
+};
+
+export const runPollerAcknowledgementTick = async (
+  config: PollerConfig,
+  token: string | null,
+): Promise<AcknowledgementReport> => {
+  const lines: Array<string> = [];
+  const problems: Array<string> = [];
+  const roleCache: RoleCache = new Map();
+  for (const repo of config.repos) {
+    try {
+      // biome-ignore lint/performance/noAwaitInLoops: repository scans share a rate-limited GitHub token and keep writes serialized.
+      await acknowledgeRepository(
+        { config, token, repo, roleCache },
+        lines,
+        problems,
+      );
+    } catch (error) {
+      problems.push(
+        `${repo}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+  return { lines, problems };
+};

package/src/poller-claim.ts

@@ -1,6 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { hasLabel } from './github-label-identity';
+import { isRecord } from './github-settings-parse';
 import { type ApprovalBinding, readApprovalBinding } from './poller-approval';
+import {
+  hiddenCommentMetadata,
+  parseHiddenCommentMetadata,
+} from './poller-comment-metadata';
 import {
   collaboratorRole,
   getIssue,
@@ -8,8 +13,13 @@ import {
   lastLabelEvent,
   listIssueComments,
 } from './poller-github';
-import { createComment } from './poller-github-write';
-import { CLAIM_MARKER, isTrustedRole } from './poller-protocol';
+import { createComment, deleteComment } from './poller-github-write';
+import {
+  CLAIM_METADATA_MARKER,
+  FIX_IN_PROGRESS,
+  isTrustedRole,
+  REVIEW_IN_PROGRESS,
+} from './poller-protocol';
 
 export type ClaimBinding = {
   readonly approval: ApprovalBinding;
@@ -28,38 +38,56 @@ type ClaimContext = {
   readonly issueNumber: number;
 };
 
+const startedMessage = (claimLabel: string) => {
+  if (claimLabel === FIX_IN_PROGRESS) {
+    return '**Fix started**\n\nThe poller is working on this issue now. It’ll open a draft pull request when the fix is ready, or ask here if it needs your input.';
+  }
+  if (claimLabel === REVIEW_IN_PROGRESS) {
+    return '**Review started**\n\nThe poller is reviewing this pull request now. It’ll post the results and take the pull request out of draft when it’s finished, or ask here if it needs your input.';
+  }
+  throw new Error(`unsupported poller claim label: ${claimLabel}`);
+};
+
 const markerBody = (marker: ClaimMarker): string =>
-  `${CLAIM_MARKER}\n${JSON.stringify(marker)}`;
+  `${startedMessage(marker.claimLabel)}\n\n${hiddenCommentMetadata(
+    CLAIM_METADATA_MARKER,
+    marker,
+  )}`;
+
+const isApprovalBinding = (value: unknown): value is ApprovalBinding =>
+  isRecord(value) &&
+  typeof value.id === 'string' &&
+  typeof value.repo === 'string' &&
+  typeof value.issueNumber === 'number' &&
+  typeof value.eventId === 'number' &&
+  typeof value.label === 'string' &&
+  typeof value.actorLogin === 'string' &&
+  typeof value.approvedAt === 'string' &&
+  typeof value.target === 'string';
 
 const parseMarker = (comment: IssueComment): ClaimMarker | null => {
-  if (!comment.body.startsWith(`${CLAIM_MARKER}\n`)) {
+  const payload = parseHiddenCommentMetadata(
+    comment.body,
+    CLAIM_METADATA_MARKER,
+  );
+  if (!isRecord(payload)) {
     return null;
   }
-  try {
-    const raw = JSON.parse(comment.body.slice(CLAIM_MARKER.length + 1)) as {
-      readonly approval?: ApprovalBinding;
-      readonly claimLabel?: unknown;
-      readonly claimEpoch?: unknown;
-      readonly nonce?: unknown;
-    };
-    if (
-      typeof raw.claimLabel !== 'string' ||
-      typeof raw.claimEpoch !== 'string' ||
-      typeof raw.nonce !== 'string' ||
-      raw.approval === undefined ||
-      typeof raw.approval.id !== 'string'
-    ) {
-      return null;
-    }
-    return {
-      approval: raw.approval,
-      claimLabel: raw.claimLabel,
-      claimEpoch: raw.claimEpoch,
-      nonce: raw.nonce,
-    };
-  } catch {
+  const raw = payload;
+  if (
+    typeof raw.claimLabel !== 'string' ||
+    typeof raw.claimEpoch !== 'string' ||
+    typeof raw.nonce !== 'string' ||
+    !isApprovalBinding(raw.approval)
+  ) {
     return null;
   }
+  return {
+    approval: raw.approval,
+    claimLabel: raw.claimLabel,
+    claimEpoch: raw.claimEpoch,
+    nonce: raw.nonce,
+  };
 };
 
 const winningMarkerId = async (
@@ -120,7 +148,11 @@ export const acquireClaim = async (
     markerBody({ ...provisional, nonce }),
   );
   const winner = await winningMarkerId(context, provisional);
-  return winner === markerId ? { ...provisional, markerId } : null;
+  if (winner !== markerId) {
+    await deleteComment(context.token, context.repo, markerId);
+    return null;
+  }
+  return { ...provisional, markerId };
 };
 
 export const validateClaim = async (

package/src/poller-commands.ts

@@ -6,6 +6,7 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
 import { resolveToken } from './github-api';
+import { runPollerAcknowledgementTick } from './poller-acknowledgements';
 import { type PollerConfig, parsePollerConfig } from './poller-config';
 import { runPollerTick } from './poller-tick';
 import { runPollerPrintUnits } from './poller-units';
@@ -13,6 +14,7 @@ import { runPollerPrintUnits } from './poller-units';
 export type PollerCommandOptions = {
   readonly configPath: string | undefined;
   readonly printUnits: boolean;
+  readonly acknowledgeOnly: boolean;
 };
 
 const loadConfig = async (configPath: string): Promise<PollerConfig> => {
@@ -62,7 +64,9 @@ export const runPollerCommand = async (
     );
     return false;
   }
-  const { lines, problems } = await runPollerTick(config, token, Date.now());
+  const { lines, problems } = options.acknowledgeOnly
+    ? await runPollerAcknowledgementTick(config, token)
+    : await runPollerTick(config, token, Date.now());
   for (const line of lines) {
     console.log(`  ${line}`);
   }
@@ -72,7 +76,7 @@ export const runPollerCommand = async (
     return false;
   }
   console.log(
-    `standards poller: tick complete (${lines.length} event(s) across ${config.repos.length} repo(s))`,
+    `standards poller: ${options.acknowledgeOnly ? 'acknowledgement ' : ''}tick complete (${lines.length} event(s) across ${config.repos.length} repo(s))`,
   );
   return true;
 };

package/src/poller-comment-metadata.ts

@@ -0,0 +1,25 @@
+const commentStart = (marker: string): string => `<!-- ${marker}\n`;
+const COMMENT_END = '\n-->';
+
+export const hiddenCommentMetadata = (marker: string, value: unknown): string =>
+  `${commentStart(marker)}${JSON.stringify(value)}${COMMENT_END}`;
+
+export const parseHiddenCommentMetadata = (
+  body: string,
+  marker: string,
+): unknown | null => {
+  const start = body.indexOf(commentStart(marker));
+  if (start === -1) {
+    return null;
+  }
+  const payloadStart = start + commentStart(marker).length;
+  const end = body.indexOf(COMMENT_END, payloadStart);
+  if (end === -1) {
+    return null;
+  }
+  try {
+    return JSON.parse(body.slice(payloadStart, end)) as unknown;
+  } catch {
+    return null;
+  }
+};

package/src/poller-fix-run.ts

@@ -31,6 +31,7 @@ import {
   FIX_FAILED,
   FIX_IN_PROGRESS,
 } from './poller-protocol';
+import { acknowledgeQueuedJob } from './poller-status';
 import {
   createWorktree,
   ensureCacheClone,
@@ -86,6 +87,7 @@ export const runFixJob = async (
     );
   }
   if (sealed === null && !allowCodex) {
+    await acknowledgeQueuedJob(deps, issue.number, preamble.approval, 'fix');
     return {
       lines: [`#${issue.number}: waiting for run capacity`],
       ranCodex: false,

package/src/poller-github-write.ts

@@ -1,7 +1,13 @@
 // Write-side label and comment operations for the poller. Kept apart from the
 // read helpers so each module stays a single reviewable concern.
 
-import { apiError, HTTP_CREATED, HTTP_OK, request } from './github-api';
+import {
+  apiError,
+  HTTP_CREATED,
+  HTTP_NO_CONTENT,
+  HTTP_OK,
+  request,
+} from './github-api';
 import { isRecord } from './github-settings-parse';
 
 const HTTP_NOT_FOUND = 404;
@@ -85,3 +91,23 @@ export const createComment = async (
   }
   return response.body.id;
 };
+
+export const deleteComment = async (
+  token: string | null,
+  repo: string,
+  commentId: number,
+): Promise<void> => {
+  const response = await request(
+    token,
+    'DELETE',
+    `/repos/${repo}/issues/comments/${commentId}`,
+  );
+  if (
+    response.status !== HTTP_NO_CONTENT &&
+    response.status !== HTTP_NOT_FOUND
+  ) {
+    throw new Error(
+      apiError(`delete comment ${commentId} in ${repo}`, response),
+    );
+  }
+};

package/src/poller-protocol.ts

@@ -16,7 +16,8 @@ export const DEFERRED_FINDING = 'deferred-finding';
 // questions and failure reports apart from human conversation.
 export const QUESTION_MARKER = '<!-- standards-poller:question -->';
 export const FAILURE_MARKER = '<!-- standards-poller:failure -->';
-export const CLAIM_MARKER = '<!-- standards-poller:claim -->';
+export const CLAIM_METADATA_MARKER = 'standards-poller:claim';
+export const QUEUE_METADATA_MARKER = 'standards-poller:queue';
 export const FIX_OUTPUT_MARKER = 'standards-poller:fix-output';
 
 // Repository roles trusted to approve automation and answer its questions.

package/src/poller-queue-marker.ts

@@ -0,0 +1,194 @@
+import { hasLabel } from './github-label-identity';
+import type { ApprovalBinding } from './poller-approval';
+import { parseHiddenCommentMetadata } from './poller-comment-metadata';
+import {
+  type IssueItem,
+  lastLabelEvent,
+  listIssueComments,
+} from './poller-github';
+import type { JobDeps } from './poller-job-shared';
+import {
+  APPROVED_FOR_FIX,
+  APPROVED_FOR_REVIEW,
+  FIX_IN_PROGRESS,
+  isTrustedRole,
+  NEEDS_CLARIFICATION,
+  QUEUE_METADATA_MARKER,
+  REVIEW_IN_PROGRESS,
+} from './poller-protocol';
+import { cachedCollaboratorRole } from './poller-trust';
+
+export type PollerJobKind = 'fix' | 'review';
+
+type ApprovalCheckpoint = {
+  readonly actorLogin: string;
+  readonly approvedAt: string;
+  readonly eventId: number;
+  readonly target: string;
+};
+
+type QueueMarker = {
+  readonly approvalId: string;
+  readonly kind: PollerJobKind;
+  readonly approval: ApprovalCheckpoint | null;
+};
+
+export const inProgressLabelFor = (kind: PollerJobKind) =>
+  kind === 'fix' ? FIX_IN_PROGRESS : REVIEW_IN_PROGRESS;
+
+export const approvalLabelFor = (kind: PollerJobKind) =>
+  kind === 'fix' ? APPROVED_FOR_FIX : APPROVED_FOR_REVIEW;
+
+export const queueMarkerFor = (
+  approval: ApprovalBinding,
+  kind: PollerJobKind,
+): QueueMarker => ({
+  approvalId: approval.id,
+  kind,
+  approval: {
+    actorLogin: approval.actorLogin,
+    approvedAt: approval.approvedAt,
+    eventId: approval.eventId,
+    target: approval.target,
+  },
+});
+
+const queueMarker = (body: string): QueueMarker | null => {
+  const raw = parseHiddenCommentMetadata(body, QUEUE_METADATA_MARKER);
+  if (typeof raw !== 'object' || raw === null) {
+    return null;
+  }
+  const candidate = raw as {
+    readonly approvalId?: unknown;
+    readonly approval?: unknown;
+    readonly kind?: unknown;
+  };
+  if (
+    typeof candidate.approvalId !== 'string' ||
+    (candidate.kind !== 'fix' && candidate.kind !== 'review')
+  ) {
+    return null;
+  }
+  if (candidate.approval === undefined) {
+    return {
+      approvalId: candidate.approvalId,
+      kind: candidate.kind,
+      approval: null,
+    };
+  }
+  if (typeof candidate.approval !== 'object' || candidate.approval === null) {
+    return null;
+  }
+  const approval = candidate.approval as {
+    readonly actorLogin?: unknown;
+    readonly approvedAt?: unknown;
+    readonly eventId?: unknown;
+    readonly target?: unknown;
+  };
+  if (
+    typeof approval.actorLogin !== 'string' ||
+    typeof approval.approvedAt !== 'string' ||
+    typeof approval.eventId !== 'number' ||
+    typeof approval.target !== 'string'
+  ) {
+    return null;
+  }
+  return {
+    approvalId: candidate.approvalId,
+    kind: candidate.kind,
+    approval: {
+      actorLogin: approval.actorLogin,
+      approvedAt: approval.approvedAt,
+      eventId: approval.eventId,
+      target: approval.target,
+    },
+  };
+};
+
+export const matchingTrustedQueueCommentIds = async (
+  deps: JobDeps,
+  issueNumber: number,
+  approvalId: string,
+  kind: PollerJobKind,
+): Promise<ReadonlyArray<number>> => {
+  const comments = await listIssueComments(deps.token, deps.repo, issueNumber);
+  const ids: Array<number> = [];
+  for (const comment of comments) {
+    const marker = queueMarker(comment.body);
+    if (marker?.approvalId === approvalId && marker.kind === kind) {
+      // biome-ignore lint/performance/noAwaitInLoops: role reads use the shared per-tick cache; marker authorship is a trust boundary.
+      const role = await cachedCollaboratorRole(
+        {
+          token: deps.token,
+          repo: deps.repo,
+          issueNumber,
+          roleCache: deps.roleCache,
+        },
+        comment.authorLogin,
+      );
+      if (isTrustedRole(role)) {
+        ids.push(comment.id);
+      }
+    }
+  }
+  return ids;
+};
+
+export const inspectQueuedAcknowledgement = async (options: {
+  readonly deps: JobDeps;
+  readonly item: IssueItem;
+  readonly kind: PollerJobKind;
+  readonly target: string;
+}): Promise<boolean> => {
+  const { deps, item, kind, target } = options;
+  const expectedLabel = approvalLabelFor(kind);
+  if (
+    !hasLabel(item.labels, expectedLabel) ||
+    hasLabel(item.labels, inProgressLabelFor(kind)) ||
+    hasLabel(item.labels, NEEDS_CLARIFICATION)
+  ) {
+    return false;
+  }
+  const comments = await listIssueComments(deps.token, deps.repo, item.number);
+  const checkpoints: Array<ApprovalCheckpoint> = [];
+  for (const comment of comments) {
+    const marker = queueMarker(comment.body);
+    if (
+      marker?.kind === kind &&
+      marker.approval !== null &&
+      marker.approval.target === target
+    ) {
+      // biome-ignore lint/performance/noAwaitInLoops: role reads use the shared per-tick cache; marker authorship is a trust boundary.
+      const role = await cachedCollaboratorRole(
+        {
+          token: deps.token,
+          repo: deps.repo,
+          issueNumber: item.number,
+          roleCache: deps.roleCache,
+        },
+        comment.authorLogin,
+      );
+      if (isTrustedRole(role)) {
+        checkpoints.push(marker.approval);
+      }
+    }
+  }
+  if (checkpoints.length === 0) {
+    return false;
+  }
+  const event = await lastLabelEvent(
+    deps.token,
+    deps.repo,
+    item.number,
+    expectedLabel,
+  );
+  return (
+    event !== null &&
+    checkpoints.some(
+      (checkpoint) =>
+        checkpoint.eventId === event.id &&
+        checkpoint.actorLogin === event.actorLogin &&
+        checkpoint.approvedAt === event.createdAt,
+    )
+  );
+};

package/src/poller-review-eligibility.ts

@@ -0,0 +1,33 @@
+import type { PullRequest } from './poller-github-pulls';
+
+export type ReviewEligibility =
+  | { readonly kind: 'eligible' }
+  | { readonly kind: 'recovering' }
+  | {
+      readonly kind: 'rejected';
+      readonly message: string;
+      readonly result: string;
+    };
+
+export const reviewEligibility = (options: {
+  readonly repo: string;
+  readonly pr: PullRequest;
+  readonly hasPlan: boolean;
+}): ReviewEligibility => {
+  const { repo, pr, hasPlan } = options;
+  if (!(pr.draft || hasPlan)) {
+    return {
+      kind: 'rejected',
+      message: 'automated review requires a draft PR',
+      result: 'rejected (not draft)',
+    };
+  }
+  if (pr.headRepo !== repo) {
+    return {
+      kind: 'rejected',
+      message: `this PR's head branch lives in ${pr.headRepo || 'an unknown repository'}; automated review runs only support same-repository branches`,
+      result: 'rejected (fork head)',
+    };
+  }
+  return { kind: hasPlan ? 'recovering' : 'eligible' };
+};

package/src/poller-review-run.ts

@@ -21,6 +21,7 @@ import {
   REVIEW_FAILED,
   REVIEW_IN_PROGRESS,
 } from './poller-protocol';
+import { reviewEligibility } from './poller-review-eligibility';
 import { executeReviewJob } from './poller-review-execution';
 import {
   readSealedReviewPlan,
@@ -28,6 +29,7 @@ import {
 } from './poller-review-output';
 import { resumeReviewedJob } from './poller-review-publication';
 import { publishReviewPlan, readReviewPlan } from './poller-review-state';
+import { acknowledgeQueuedJob } from './poller-status';
 import { ensureCacheClone, localBranchExists } from './poller-workspace';
 
 const REVIEW_LABELS: JobLabels = {
@@ -73,30 +75,15 @@ export const runReviewJob = async (
       ranCodex: false,
     };
   }
-  if (!pr.draft && plan === null) {
-    await failJob(
-      deps,
-      REVIEW_LABELS,
-      pr.number,
-      'automated review requires a draft PR',
-    );
-    return {
-      lines: [`PR #${pr.number}: rejected (not draft)`],
-      ranCodex: false,
-    };
-  }
-  // Fork PRs are out of scope: their head branch lives in a repository the
-  // poller must not push to, and pushing a same-named branch to the base repo
-  // would fake a review. Fail explicitly instead of pretending.
-  if (pr.headRepo !== repo) {
-    await failJob(
-      deps,
-      REVIEW_LABELS,
-      pr.number,
-      `this PR's head branch lives in ${pr.headRepo || 'an unknown repository'}; automated review runs only support same-repository branches`,
-    );
+  const eligibility = reviewEligibility({
+    repo,
+    pr,
+    hasPlan: plan !== null,
+  });
+  if (eligibility.kind === 'rejected') {
+    await failJob(deps, REVIEW_LABELS, pr.number, eligibility.message);
     return {
-      lines: [`PR #${pr.number}: rejected (fork head)`],
+      lines: [`PR #${pr.number}: ${eligibility.result}`],
       ranCodex: false,
     };
   }
@@ -113,6 +100,7 @@ export const runReviewJob = async (
     throw new Error(`sealed output on ${outputBranch} is invalid`);
   }
   if (plan === null && sealed === null && !allowCodex) {
+    await acknowledgeQueuedJob(deps, pr.number, preamble.approval, 'review');
     return {
       lines: [`PR #${pr.number}: waiting for run capacity`],
       ranCodex: false,

package/src/poller-status.ts

@@ -0,0 +1,133 @@
+import { hasLabel } from './github-label-identity';
+import {
+  type ApprovalBinding,
+  issueRevision,
+  prRevision,
+  readApprovalBinding,
+} from './poller-approval';
+import { hiddenCommentMetadata } from './poller-comment-metadata';
+import { getIssue } from './poller-github';
+import { getPullRequest } from './poller-github-pulls';
+import { createComment, deleteComment } from './poller-github-write';
+import type { JobDeps } from './poller-job-shared';
+import { NEEDS_CLARIFICATION, QUEUE_METADATA_MARKER } from './poller-protocol';
+import {
+  approvalLabelFor,
+  inProgressLabelFor,
+  matchingTrustedQueueCommentIds,
+  type PollerJobKind,
+  queueMarkerFor,
+} from './poller-queue-marker';
+import { reviewEligibility } from './poller-review-eligibility';
+
+const queuedMessage = (kind: PollerJobKind) =>
+  kind === 'fix'
+    ? '**Fix queued**\n\nThe poller has picked this up and will start work as soon as a run is available. You don’t need to do anything else.'
+    : '**Review queued**\n\nThe poller has picked this up and will start the review as soon as a run is available. You don’t need to do anything else.';
+
+const isStillQueueable = async (
+  deps: JobDeps,
+  issueNumber: number,
+  approval: ApprovalBinding,
+  kind: PollerJobKind,
+): Promise<boolean> => {
+  const expectedApprovalLabel = approvalLabelFor(kind);
+  if (
+    approval.repo !== deps.repo ||
+    approval.issueNumber !== issueNumber ||
+    approval.label !== expectedApprovalLabel
+  ) {
+    return false;
+  }
+  const issue = await getIssue(deps.token, deps.repo, issueNumber);
+  if (
+    !hasLabel(issue.labels, expectedApprovalLabel) ||
+    hasLabel(issue.labels, inProgressLabelFor(kind)) ||
+    hasLabel(issue.labels, NEEDS_CLARIFICATION)
+  ) {
+    return false;
+  }
+  let target = issueRevision(issue);
+  if (kind === 'review') {
+    const pr = await getPullRequest(deps.token, deps.repo, issueNumber);
+    if (
+      reviewEligibility({
+        repo: deps.repo,
+        pr,
+        hasPlan: false,
+      }).kind !== 'eligible'
+    ) {
+      return false;
+    }
+    target = prRevision(pr.baseRef, pr.baseSha, pr.headSha);
+  }
+  if (target !== approval.target) {
+    return false;
+  }
+  const currentApproval = await readApprovalBinding(
+    {
+      token: deps.token,
+      repo: deps.repo,
+      issueNumber,
+    },
+    expectedApprovalLabel,
+    target,
+  );
+  return (
+    typeof currentApproval !== 'string' && currentApproval.id === approval.id
+  );
+};
+
+export const acknowledgeQueuedJob = async (
+  deps: JobDeps,
+  issueNumber: number,
+  approval: ApprovalBinding,
+  kind: PollerJobKind,
+): Promise<boolean> => {
+  const expected = queueMarkerFor(approval, kind);
+  const current = await getIssue(deps.token, deps.repo, issueNumber);
+  if (
+    hasLabel(current.labels, inProgressLabelFor(kind)) ||
+    hasLabel(current.labels, NEEDS_CLARIFICATION)
+  ) {
+    return false;
+  }
+  if (
+    (
+      await matchingTrustedQueueCommentIds(
+        deps,
+        issueNumber,
+        expected.approvalId,
+        kind,
+      )
+    ).length > 0
+  ) {
+    return false;
+  }
+  const markerId = await createComment(
+    deps.token,
+    deps.repo,
+    issueNumber,
+    `${queuedMessage(kind)}\n\n${hiddenCommentMetadata(
+      QUEUE_METADATA_MARKER,
+      expected,
+    )}`,
+  );
+  const [winner] = [
+    ...(await matchingTrustedQueueCommentIds(
+      deps,
+      issueNumber,
+      expected.approvalId,
+      kind,
+    )),
+  ].sort((left, right) => left - right);
+  if (winner !== markerId) {
+    await deleteComment(deps.token, deps.repo, markerId);
+    return false;
+  }
+  if (!(await isStillQueueable(deps, issueNumber, approval, kind))) {
+    await deleteComment(deps.token, deps.repo, markerId);
+    return false;
+  }
+  return true;
+};

package/src/poller-trust.ts

@@ -19,7 +19,7 @@ export type TrustContext = {
   readonly roleCache: RoleCache;
 };
 
-const cachedRole = async (
+export const cachedCollaboratorRole = async (
   context: TrustContext,
   username: string,
 ): Promise<string> => {
@@ -53,7 +53,7 @@ const lastTrustedQuestionIndex = async (
     const comment = comments[index];
     if (comment !== undefined && hasQuestionMarker(comment)) {
       // biome-ignore lint/performance/noAwaitInLoops: role lookups go through the shared per-tick cache; parallel lookups would race it and duplicate API reads.
-      const role = await cachedRole(context, comment.authorLogin);
+      const role = await cachedCollaboratorRole(context, comment.authorLogin);
       if (isTrustedRole(role)) {
         return index;
       }
@@ -87,7 +87,7 @@ export const answerState = async (
     );
   for (const comment of candidates) {
     // biome-ignore lint/performance/noAwaitInLoops: role lookups go through the shared per-tick cache; parallel lookups would race it and duplicate API reads.
-    const role = await cachedRole(context, comment.authorLogin);
+    const role = await cachedCollaboratorRole(context, comment.authorLogin);
     if (isTrustedRole(role)) {
       answers.push(comment.body);
     }

package/src/poller-units.ts

@@ -8,11 +8,11 @@ import { fileURLToPath } from 'node:url';
 import type { PollerConfig } from './poller-config';
 
 const SERVICE_NAME = 'standards-poller';
-// Bounds idle pickup latency while preserving a full cooldown after each tick:
-// OnUnitInactiveSec starts counting when the oneshot service finishes.
-// AccuracySec matters at this scale: systemd's default 1min accuracy would
-// stretch a 1min interval into a 1-2min window.
-const TICK_INTERVAL_MINUTES = 1;
+// OnUnitInactiveSec starts counting when each oneshot service finishes.
+// Keep worker pickup prompt while giving the acknowledgement observer enough
+// API headroom for mixed queues, recovery plans, pagination, and worker calls.
+const WORKER_INTERVAL_MINUTES = 1;
+export const ACKNOWLEDGEMENT_INTERVAL_MINUTES = 5;
 // Non-agent tick work: stale sweeps, clone/fetch, GitHub reads and writes.
 const TICK_OVERHEAD_MINUTES = 30;
 const MAX_ASCII_CONTROL_CODE = 31;
@@ -50,7 +50,12 @@ const tickBudgetMinutes = (config: PollerConfig): number =>
 export const renderUnits = (
   configPath: string,
   config: PollerConfig,
-): { readonly service: string; readonly timer: string } => ({
+): {
+  readonly service: string;
+  readonly timer: string;
+  readonly acknowledgementService: string;
+  readonly acknowledgementTimer: string;
+} => ({
   service: `[Unit]
 Description=Standards fix poller tick
 After=network-online.target
@@ -66,7 +71,29 @@ Description=Run the standards fix poller on an interval
 
 [Timer]
 OnBootSec=2min
-OnUnitInactiveSec=${TICK_INTERVAL_MINUTES}min
+OnUnitInactiveSec=${WORKER_INTERVAL_MINUTES}min
+AccuracySec=15s
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`,
+  acknowledgementService: `[Unit]
+Description=Acknowledge queued standards poller requests
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=${quoteSystemdExecArg(process.execPath)} ${quoteSystemdExecArg(cliEntryPath())} poller --acknowledge-only --config ${quoteSystemdExecArg(configPath)}
+TimeoutStartSec=${TICK_OVERHEAD_MINUTES}min
+`,
+  acknowledgementTimer: `[Unit]
+Description=Check for newly queued standards poller requests
+
+[Timer]
+OnBootSec=1min
+OnUnitInactiveSec=${ACKNOWLEDGEMENT_INTERVAL_MINUTES}min
 AccuracySec=15s
 Persistent=true
 
@@ -84,4 +111,8 @@ export const runPollerPrintUnits = (
   console.log(units.service);
   console.log(`# ${SERVICE_NAME}.timer`);
   console.log(units.timer);
+  console.log(`# ${SERVICE_NAME}-acknowledgements.service`);
+  console.log(units.acknowledgementService);
+  console.log(`# ${SERVICE_NAME}-acknowledgements.timer`);
+  console.log(units.acknowledgementTimer);
 };