create-extractor: use the scheduler's status labels; drop add-live-case

Retires this pipeline's two invented labels for the scheduler's own
vocabulary. `extractor-request` stays for the issue's whole life — it
marks what the issue IS — and its STATE is now:

  extractor-in-progress          -> agent-running
  extractor-blocked-needs-human  -> needs-human

The scheduler guarantees both labels exist before any preprocessing runs,
so the worker's own label-creation goes away entirely. `ready-for-agent`
is deliberately never applied to a request: it is the executor's trigger.

A request stays claimed while its PR is in review, which outlives the
executor's 3h stale-claim sweep — that sweep is now scoped to dispatch
issues, so this pipeline releases its own stale claims instead: a claimed
request with no open `claude/extractor/*` PR naming it, quiet past a 6h
grace period, is released with a comment and picked up again next pass.
A run that dies between claiming and delivering no longer strands its
request silently, which the invented label never handled either.

Also removes the add-live-case skill. What it uniquely held — the
record-a-page procedure and the gardening flow — is four lines now that
the record-page task acts on a committed `.url`, and it belongs beside the
live-test contract it depends on, so it moves into testing-guide. The rest
of the skill was already duplicated there.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016NgBmWQmxLFPybrhSTz8i3

Author: claude

.claudinite/local/packs/gcec/README.md

@@ -17,7 +17,7 @@ fingerprinted or seeded.
 | Prose | [RULES.md](RULES.md) — working rules, owner commands, testing invariants, codebase gotchas, workflow-failure classification, architecture rules of the road, the capture policy |
 | Checks | [test-offline-list-sync](test-offline-list-sync.mjs) (+ red-first fixtures in [pack.test.mjs](pack.test.mjs), run by this repo's own `npm test`) |
 | Daily tasks | none |
-| Skills | [snapshot-approval](skills/snapshot-approval/SKILL.md) · [merge-and-ci](skills/merge-and-ci/SKILL.md) · [testing-guide](skills/testing-guide/SKILL.md) · [add-live-case](skills/add-live-case/SKILL.md) |
+| Skills | [snapshot-approval](skills/snapshot-approval/SKILL.md) · [merge-and-ci](skills/merge-and-ci/SKILL.md) · [testing-guide](skills/testing-guide/SKILL.md) |
 
 ## Rules
 

.claudinite/local/packs/gcec/RULES.md

@@ -2,7 +2,7 @@
 
 The project's standing working rules — injected at session start while this pack
 is declared. Activity-scoped procedures live in this pack's skills
-(snapshot-approval, merge-and-ci, testing-guide, add-live-case) and surface on
+(snapshot-approval, merge-and-ci, testing-guide) and surface on
 demand; the extractor-automation domain's standing rules are the "Extractor
 pipeline" section below, and its three scheduled tasks live under `tasks/`.
 
@@ -147,8 +147,8 @@ Standing rules for the extractor-automation domain — the three gcec pack
 [`tasks/`](tasks/): **create-extractor** (an `extractor-request` issue → a PR
 adding site support), **record-page** (records a committed `.url`'s cached page),
 and the weekly **fallback-extractor-improvements** (read a spec only when working
-on that pipeline). Adding a cached live case is the
-[add-live-case](skills/add-live-case/SKILL.md) skill.
+on that pipeline). Adding or refreshing a cached live case by hand is the
+[testing-guide](skills/testing-guide/SKILL.md) skill.
 
 - **All page fetching goes through [`scraperapi.mjs`](scraperapi.mjs), from a
   task's preprocessing worker and nowhere else.** A rendered fetch through
@@ -184,7 +184,7 @@ on that pipeline). Adding a cached live case is the
   `.` / `-` separators are always day-first regardless (#686).
 - **An unrecordable page is a dead end, not a failed run.** When a fetch can't
   produce a page (bot wall, dead URL, empty render), create-extractor's
-  preprocessing labels the request `extractor-blocked-needs-human` with the reason
+  preprocessing labels the request `needs-human` with the reason
   and exits **0** — a task failure would converge to a `needs-human` dispatch
   issue as well, duplicating the signal and implying the pipeline broke when it
   correctly declined. Same for record-page: the pages that did record still land.

.claudinite/local/packs/gcec/pack.mjs

@@ -18,6 +18,6 @@ export default {
   marker: null,
   prose: 'RULES.md',
   rules: [testOfflineListSync],
-  skills: ['snapshot-approval', 'merge-and-ci', 'testing-guide', 'add-live-case'],
+  skills: ['snapshot-approval', 'merge-and-ci', 'testing-guide'],
   run_daily: [],
 };

.claudinite/local/packs/gcec/skills/add-live-case/SKILL.md

@@ -18,8 +18,8 @@ npm test               # everything above except e2e
 The invariants (mirror tree, reviewed-contract cases, `REFERENCE_NOW` floor,
 refusal-test discipline) are always-loaded in the gcec pack's RULES.md. General
 test discipline (see-it-fail, green-twice, high-watermark gating) is canon.
-Adding a cached live case is the gcec pack's **add-live-case**
-skill; the fallback-coverage gate's invariants are in that pack's RULES.md.
+Adding a cached live case is covered under "Live integration tests" below; the
+fallback-coverage gate's invariants are in the gcec pack's RULES.md.
 
 ## The requirements model — every leaf has exactly one case
 
@@ -49,11 +49,24 @@ is *claimed*, not every leaf *faithfully* verified (#435; the banner in
 `expected/`: `expected.events` is the **complete, exact** array the extractor
 produces — deep-equal on `title`/`start`/`end`/`location`/`ctz`/`details`, no
 matchers, array length included. The page URL lives **only** in
-`data/server-fetched/<name>.url` (single source of truth — the fetch workflow
-and the test both read it; never in the case file). Tests run offline against
-the committed cached HTML, loaded into a DOM at the `.url`'s URL so hostname
-detection behaves exactly as in Chrome. `test.yml` never fetches — recording
-goes through the record-page task (see add-live-case).
+`data/server-fetched/<name>.url` (single source of truth — the recorder and the
+test both read it; never in the case file). Tests run offline against the
+committed cached HTML, loaded into a DOM at the `.url`'s URL so hostname
+detection behaves exactly as in Chrome. `test.yml` never fetches.
+
+**Adding one.** Usually you don't: file an `extractor-request` issue with the
+event URL and the `create-extractor` task records the page, writes the
+extractor, and opens the PR. To add a case by hand, land the `.url` alone first
+— a committed `.url` with no sibling `.html` *is* the request the `record-page`
+task acts on, so it fetches the page (ScraperAPI; this sandbox is bot-blocked)
+and opens a PR carrying it. Merge that, then run `npm run test:live` and paste
+the printed values into `expected/<name>.json` — never hand-write them.
+
+**Gardening.** When an event page is taken down, point `<name>.url` at a newer
+event **and delete the stale `<name>.html`** in the same commit; that is the
+whole re-record request. Until an HTML file exists, `test:live` fails with
+`Missing cached HTML for "<name>"`, so land the refresh before (or with) the
+case's updated `expected`.
 
 ## UI snapshots
 

.claudinite/local/packs/gcec/skills/testing-guide/SKILL.md

@@ -12,8 +12,9 @@
 //   2. triage each eligible one oldest-first (triage.js, over the committed
 //      sources' real matches() + the popup's classifyHost) and CLOSE every
 //      deny/allow/duplicate with its canned message — no agent, no branch;
-//   3. for the first request that genuinely needs an extractor: claim it, branch,
-//      scaffold, prove the offline baseline green, and commit;
+//   3. for the first request that genuinely needs an extractor: claim it
+//      (`agent-running`, the scheduler's own label — no custom vocabulary here),
+//      branch, scaffold, prove the offline baseline green, and commit;
 //   4. RECORD THE PAGE through ScraperAPI directly. Preprocessing runs inside
 //      Actions, where SCRAPER_API_KEY already lives (the task names it in
 //      `required_secrets`, which the wiring converge stamps into the workflow).
@@ -48,22 +49,31 @@ const { runTriage } = require('./triage.js');
 const { addSample } = require('./attach-sample-url.js');
 
 const API = 'https://api.github.com';
+// `extractor-request` marks the issue KIND (the form applies it; it stays for the
+// issue's life). Its STATE uses the scheduler's own labels rather than any
+// invented here — the scheduler guarantees they exist before preprocessing runs,
+// so nothing below has to create them:
+//   agent-running — this pipeline owns the request (from claim until its PR lands)
+//   needs-human   — handed over; the pipeline will not pick it up again
+// `ready-for-agent` is never applied to a request: it is the executor's trigger.
 const REQUEST_LABEL = 'extractor-request';
-const BLOCKED_LABEL = 'extractor-blocked-needs-human';
-// The claim label. It is what makes the precondition's cheap gate correct across
-// hours: the scheduler runs this task hourly and does NOT know a previous run is
-// still in flight (preprocessing runs before, and independently of, the dispatch
-// issue's at-most-one-open guard). A claimed request drops out of the precondition's
-// eligible set, so an in-flight extractor is never scaffolded twice.
-const CLAIMED_LABEL = 'extractor-in-progress';
+const CLAIMED_LABEL = 'agent-running';
+const BLOCKED_LABEL = 'needs-human';
+const BRANCH_PREFIX = 'claude/extractor/';
 const DATA_DIR = 'dev/requirements/extractor/data/server-fetched';
 
+// How long a claimed request with nothing to show for it may sit before this
+// pipeline releases it. The executor's stale-`agent-running` sweep covers dispatch
+// issues only (it cannot know that a request stays claimed while its PR is in
+// review), so releasing our OWN stale claims is this worker's job.
+const STALE_CLAIM_MS = 6 * 60 * 60 * 1000;
+
 // --- pure helpers (unit-tested; no I/O) --------------------------------------
 
 // The requests this run may act on, oldest first. Mirrors the precondition's
-// eligibility exactly (task.mjs `eligibleRequests`) so the gate and the worker can
-// never disagree about what "eligible" means — the worker re-derives it from full
-// issue objects rather than trusting the gate's older snapshot.
+// eligibility exactly so the gate and the worker can never disagree about what
+// "eligible" means — the worker re-derives it from full issue objects rather than
+// trusting the gate's older snapshot.
 export function eligible(issues) {
   const labelsOf = (i) => (i.labels ?? []).map((l) => (typeof l === 'string' ? l : l?.name ?? ''));
   return (issues ?? [])
@@ -77,6 +87,24 @@ export function eligible(issues) {
     .sort((a, b) => a.number - b.number);
 }
 
+// Claimed requests whose claim is stale: nothing this pipeline produced is still
+// open for them (no `claude/extractor/*` PR says `Closes #N`) and the issue has
+// been quiet past the grace period — so a run died between claiming and delivering.
+// Releasing the claim makes them eligible again next hour. `openPrs` is the repo's
+// open PRs; `now` is passed in so this is pure.
+export function staleClaims(issues, openPrs, now) {
+  const claimedByPr = new Set(
+    (openPrs ?? [])
+      .filter((pr) => String(pr?.head?.ref ?? '').startsWith(BRANCH_PREFIX))
+      .flatMap((pr) => [...String(pr?.body ?? '').matchAll(/\bCloses #(\d+)/gi)].map((m) => Number(m[1]))),
+  );
+  return (issues ?? [])
+    .filter((i) => (i.labels ?? []).some((l) => (typeof l === 'string' ? l : l?.name) === CLAIMED_LABEL))
+    .filter((i) => !claimedByPr.has(i.number))
+    .filter((i) => now - new Date(i.updated_at ?? 0).getTime() > STALE_CLAIM_MS)
+    .map((i) => i.number);
+}
+
 // The PR title for a finished run, by mode — the same two phrasings the routine
 // spec used to ask the agent to write by hand.
 export function prTitle(mode, host, sourceBase) {
@@ -115,14 +143,6 @@ async function gh(path, { method = 'GET', body } = {}) {
 
 const comment = (n, text) => gh(`/repos/${REPO}/issues/${n}/comments`, { method: 'POST', body: { body: text } });
 
-// GitHub 422s when an unknown label is applied and never creates one on demand, so
-// the thing that assigns a label guarantees it first (idempotent; self-healing if
-// someone deletes it).
-async function ensureLabel(name, color, description) {
-  const { status } = await gh(`/repos/${REPO}/labels`, { method: 'POST', body: { name, color, description } });
-  if (status !== 201 && status !== 422) console.log(`! could not ensure label "${name}": ${status}`);
-}
-
 const addLabel = (n, name) => gh(`/repos/${REPO}/issues/${n}/labels`, { method: 'POST', body: { labels: [name] } });
 const removeLabel = (n, name) => gh(`/repos/${REPO}/issues/${n}/labels/${encodeURIComponent(name)}`, { method: 'DELETE' });
 const closeNotPlanned = (n) => gh(`/repos/${REPO}/issues/${n}`, { method: 'PATCH', body: { state: 'closed', state_reason: 'not_planned' } });
@@ -163,7 +183,6 @@ async function closeSkipped(issue, decision) {
 // release the claim. Never a task failure — the pipeline correctly declining a page
 // is a normal outcome.
 async function handToHuman(number, why) {
-  await ensureLabel(BLOCKED_LABEL, 'D93F0B', 'An automated extractor run stopped here and needs a maintainer');
   await comment(number, why);
   await addLabel(number, BLOCKED_LABEL);
   await removeLabel(number, CLAIMED_LABEL);
@@ -236,9 +255,22 @@ export async function main() {
   if (!REPO || !TOKEN) throw new Error('no CLAUDINITE_REPO/GITHUB_TOKEN — not in an Actions context');
   if (!scraperKey) throw new Error('SCRAPER_API_KEY is not set');
 
-  const requests = eligible(await openRequests());
+  const allRequests = await openRequests();
+
+  // Release our own stale claims first (the executor's sweep covers dispatch
+  // issues only). A request claimed by a run that died before delivering becomes
+  // eligible again; one whose PR is still open stays claimed however long review
+  // takes.
+  const { json: openPrs } = await gh(`/repos/${REPO}/pulls?state=open&per_page=100`);
+  for (const number of staleClaims(allRequests, Array.isArray(openPrs) ? openPrs : [], Date.now())) {
+    await removeLabel(number, CLAIMED_LABEL);
+    await comment(number, 'Releasing this request: an automated run claimed it but never delivered a pull request. The pipeline will pick it up again on its next pass.');
+    console.log(`create-extractor: released a stale claim on #${number}`);
+  }
+
+  const requests = eligible(allRequests);
   if (!requests.length) {
-    console.log('create-extractor: no eligible request (the precondition\'s snapshot is stale) — nothing to do');
+    console.log('create-extractor: nothing eligible to act on this run');
     return;
   }
 
@@ -253,7 +285,7 @@ export async function main() {
     const d = await runTriage({ body: issue.body ?? '', title: issue.title, number: issue.number }, undefined, peers);
     if (d.skipAgent) { await closeSkipped(issue, d); continue; }
     if (!d.url || !d.branch) {
-      await handToHuman(issue.number, 'This request has no parseable event URL, so the pipeline could not act on it. Edit the issue to include the event page URL and remove the `extractor-blocked-needs-human` label to retry.');
+      await handToHuman(issue.number, 'This request has no parseable event URL, so the pipeline could not act on it. Edit the issue to include the event page URL and remove the `needs-human` label to retry.');
       continue;
     }
     target = issue;
@@ -267,7 +299,6 @@ export async function main() {
 
   // Claim it before any expensive work, so the next hourly run's precondition sees
   // it as in flight even if this run dies partway.
-  await ensureLabel(CLAIMED_LABEL, '0E8A16', 'An automated extractor run is working on this request');
   await addLabel(target.number, CLAIMED_LABEL);
   console.log(`create-extractor: #${target.number} → ${decision.host} (${decision.mode} mode, case ${decision.caseName})`);
 

.claudinite/local/packs/gcec/tasks/create-extractor/prepare.mjs

@@ -85,8 +85,12 @@ triggers `test.yml` on the PR; one green run suffices.
 **Bail** (the page was not one usable event, or the postcondition failed): leave
 the case's `events` empty, make no source change, **close the draft PR**, comment
 a one-sentence diagnosis of what the page actually is on the request issue, and
-label it `extractor-blocked-needs-human` (removing `extractor-in-progress`). No
-PR, no merge.
+swap its `agent-running` label for `needs-human`. No PR, no merge.
+
+Either way the request keeps `extractor-request` — that marks what the issue *is*,
+for its whole life; `agent-running` / `needs-human` carry its state. On success
+leave `agent-running` in place: it is what stops the pipeline re-scaffolding the
+request while its PR is in review, and merging the PR closes the issue.
 
 ---
 
@@ -118,10 +122,10 @@ venue's zone — it neither supplies the `ctz` nor vetoes deriving one from the
 
 ## Manual fallback
 
-When the pipeline hands an issue to a human (`extractor-blocked-needs-human`), or
-to add a source by hand: same shape — add `custom/<site>.js`, `npm run index`,
+When the pipeline hands an issue to a human (`needs-human`), or to add a source by
+hand: same shape — add `custom/<site>.js`, `npm run index`,
 register the host in `supportedDomains` (`extension/fallback-lists.json`), add a
-reviewed case (the [add-live-case](../../skills/add-live-case/SKILL.md) skill), and
+reviewed case (the [testing-guide](../../skills/testing-guide/SKILL.md) skill), and
 record the host as an extractor-support requirement leaf in
 `dev/requirements/requirements.md` §11 (see
 [`dev/requirements/README.md`](../../../../../../dev/requirements/README.md)).