pr-report-core 0.0.5 → 0.1.0

package/src/checks.test.mts

@@ -8,6 +8,7 @@ import {
   statesFromCheckRuns,
   summarizeChecks,
 } from './checks.mjs';
+import type { ContextState } from './types.mjs';
 
 describe(classifyCheckRun, () => {
   test('an unfinished run is pending whatever it last concluded', () => {
@@ -60,7 +61,7 @@ describe(summarizeChecks, () => {
   test('every required context green is a pass', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'passed'],
         ['no-skip-ci-label', 'passed'],
       ]),
@@ -79,7 +80,9 @@ describe(summarizeChecks, () => {
     // absent from the check list rather than pending in it.
     const summary = summarizeChecks({
       required,
-      reported: new Map([['code-check-result / result', 'passed']]),
+      reported: new Map<string, ContextState>([
+        ['code-check-result / result', 'passed'],
+      ]),
       paused: false,
       running: false,
       baseCovered: true,
@@ -95,7 +98,7 @@ describe(summarizeChecks, () => {
   test('a failure outranks anything still running', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'failed'],
         ['no-skip-ci-label', 'pending'],
       ]),
@@ -117,7 +120,7 @@ describe(summarizeChecks, () => {
     // asks about.
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'failed'],
         ['no-skip-ci-label', 'pending'],
       ]),
@@ -136,7 +139,7 @@ describe(summarizeChecks, () => {
   test('a skipped context counts as met and is listed as skipped', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'skipped'],
         ['no-skip-ci-label', 'passed'],
       ]),
@@ -155,7 +158,7 @@ describe(summarizeChecks, () => {
   test('anything still running on the commit keeps the verdict pending', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'passed'],
         ['no-skip-ci-label', 'passed'],
       ]),
@@ -173,7 +176,7 @@ describe(summarizeChecks, () => {
   test('a failure is not hidden by something still running', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'failed'],
         ['no-skip-ci-label', 'passed'],
       ]),
@@ -188,7 +191,7 @@ describe(summarizeChecks, () => {
   test('a context nothing requires is not counted', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([
+      reported: new Map<string, ContextState>([
         ['code-check-result / result', 'passed'],
         ['no-skip-ci-label', 'passed'],
         ['some-optional-job', 'failed'],
@@ -213,7 +216,7 @@ describe(summarizeChecks, () => {
     test('a context that never reported is not waited for', () => {
       const summary = summarizeChecks({
         required: withLint,
-        reported: new Map([
+        reported: new Map<string, ContextState>([
           ['code-check-result / result', 'passed'],
           ['no-skip-ci-label', 'passed'],
         ]),
@@ -236,7 +239,7 @@ describe(summarizeChecks, () => {
       // on it at all; that is not a pass over zero contexts.
       const summary = summarizeChecks({
         required: withLint,
-        reported: new Map(),
+        reported: new Map<string, ContextState>(),
         paused: false,
         running: false,
         baseCovered: false,
@@ -252,7 +255,7 @@ describe(summarizeChecks, () => {
     test('a context that reported is judged as anywhere else', () => {
       const summary = summarizeChecks({
         required: withLint,
-        reported: new Map([
+        reported: new Map<string, ContextState>([
           ['code-check-result / result', 'failed'],
           ['no-skip-ci-label', 'pending'],
         ]),
@@ -270,7 +273,9 @@ describe(summarizeChecks, () => {
   test('on a base the ruleset covers, nothing is excused from reporting', () => {
     const summary = summarizeChecks({
       required,
-      reported: new Map([['code-check-result / result', 'passed']]),
+      reported: new Map<string, ContextState>([
+        ['code-check-result / result', 'passed'],
+      ]),
       paused: false,
       running: false,
       baseCovered: true,
@@ -422,7 +427,7 @@ describe(reportedContexts, () => {
         [completedRun('code-check-result / result', 'success')],
         [{ context: 'no-skip-ci-label', state: 'pending' }],
       ),
-      new Map([
+      new Map<string, ContextState>([
         ['code-check-result / result', 'passed'],
         ['no-skip-ci-label', 'pending'],
       ]),
@@ -435,7 +440,7 @@ describe(reportedContexts, () => {
         [completedRun('lint', 'failure')],
         [{ context: 'lint', state: 'success' }],
       ),
-      new Map([['lint', 'failed']]),
+      new Map<string, ContextState>([['lint', 'failed']]),
     );
 
     assert.deepStrictEqual(
@@ -443,7 +448,7 @@ describe(reportedContexts, () => {
         [completedRun('lint', 'success')],
         [{ context: 'lint', state: 'pending' }],
       ),
-      new Map([['lint', 'pending']]),
+      new Map<string, ContextState>([['lint', 'pending']]),
     );
   });
 });

package/src/labels.mts

@@ -77,3 +77,23 @@ export const PRIORITY_MID_LABEL = 'priority:mid';
  * `unblock-prs`: what is held is simply not labelled `merge-queued`.
  */
 export const PENDING_LABEL = 'pending';
+
+/**
+ * The label that says someone has started an issue, before there is a pull
+ * request to say so. `start-issue` puts it on, and refuses an issue that
+ * already carries it, so that two sessions do not pick up the same one; the
+ * Pull Requests Manager page and `pr-report` show a startable issue carrying
+ * it as in progress, as they show one an open pull request closes
+ * (`start-after.mts`'s `progressOf`). Nothing takes it off when the work
+ * merges: the issue closes, and the label with it stops mattering.
+ */
+export const IN_PROGRESS_LABEL = 'in-progress';
+
+/**
+ * The label that says someone means to start an issue next. It holds nothing
+ * back — `start-issue` takes it off as it puts {@link IN_PROGRESS_LABEL} on —
+ * and only tells whoever is choosing what to start that this one is spoken
+ * for; the page and `pr-report` show a startable issue carrying it as
+ * planned.
+ */
+export const PLANNED_LABEL = 'planned';

package/src/merge-after.test.mts

@@ -141,7 +141,7 @@ describe(findMergeAfterCycles, () => {
   test('finds nothing in a chain', () => {
     assert.deepStrictEqual(
       findMergeAfterCycles(
-        new Map([
+        new Map<number, readonly number[]>([
           [3, [2]],
           [2, [1]],
           [1, []],
@@ -154,7 +154,7 @@ describe(findMergeAfterCycles, () => {
   test('finds nothing in a diamond', () => {
     assert.deepStrictEqual(
       findMergeAfterCycles(
-        new Map([
+        new Map<number, readonly number[]>([
           [4, [2, 3]],
           [3, [1]],
           [2, [1]],
@@ -168,7 +168,7 @@ describe(findMergeAfterCycles, () => {
   test('finds a two-node cycle, starting at its lowest number', () => {
     assert.deepStrictEqual(
       findMergeAfterCycles(
-        new Map([
+        new Map<number, readonly number[]>([
           [2, [1]],
           [1, [2]],
         ]),
@@ -178,7 +178,10 @@ describe(findMergeAfterCycles, () => {
   });
 
   test('finds a pull request that declares itself', () => {
-    assert.deepStrictEqual(findMergeAfterCycles(new Map([[7, [7]]])), [[7]]);
+    assert.deepStrictEqual(
+      findMergeAfterCycles(new Map<number, readonly number[]>([[7, [7]]])),
+      [[7]],
+    );
   });
 
   test('reports a cycle once however it is entered', () => {
@@ -186,7 +189,7 @@ describe(findMergeAfterCycles, () => {
     // different node each time.
     assert.deepStrictEqual(
       findMergeAfterCycles(
-        new Map([
+        new Map<number, readonly number[]>([
           [9, [1]],
           [10, [2]],
           [1, [2]],
@@ -201,7 +204,7 @@ describe(findMergeAfterCycles, () => {
   test('finds two independent cycles', () => {
     assert.deepStrictEqual(
       findMergeAfterCycles(
-        new Map([
+        new Map<number, readonly number[]>([
           [1, [2]],
           [2, [1]],
           [5, [6]],
@@ -216,6 +219,9 @@ describe(findMergeAfterCycles, () => {
   });
 
   test('follows an edge to a pull request that declared nothing', () => {
-    assert.deepStrictEqual(findMergeAfterCycles(new Map([[1, [2]]])), []);
+    assert.deepStrictEqual(
+      findMergeAfterCycles(new Map<number, readonly number[]>([[1, [2]]])),
+      [],
+    );
   });
 });

package/src/queue-order.mts

@@ -197,7 +197,10 @@ export const isMergeableState = (mergeState: string): boolean =>
 export const queueGraph = (
   pulls: readonly QueueGraphMember[],
   defaultBranch: string,
-  startAfterOf: ReadonlyMap<number, readonly number[]> = new Map(),
+  startAfterOf: ReadonlyMap<number, readonly number[]> = new Map<
+    number,
+    readonly number[]
+  >(),
 ): QueueGraph => {
   const sorted = pulls.toSorted((a, b) => a.number - b.number);
 
@@ -207,7 +210,7 @@ export const queueGraph = (
   const inheritedOrders = inheritStartAfter({
     pulls: sorted.map(({ number, closes = [] }) => ({ number, closes })),
     startAfterOf,
-    openIssues: new Set(),
+    openIssues: new Set<number>(),
   });
 
   const declared: ReadonlyMap<number, readonly number[]> = new Map(

package/src/queue-order.test.mts

@@ -14,6 +14,7 @@ import {
   type QueueFacts,
   type QueueGraphMember,
 } from './queue-order.mjs';
+import type { QueueOwner } from './queue-owner.mjs';
 
 describe(queueGraph, () => {
   test('reads the declared order and the stack together, and the cycles in them', () => {
@@ -26,11 +27,14 @@ describe(queueGraph, () => {
       'main',
     );
 
-    assert.deepStrictEqual(graph.stackParents, new Map([[2, 1]]));
+    assert.deepStrictEqual(
+      graph.stackParents,
+      new Map<number, number>([[2, 1]]),
+    );
 
     assert.deepStrictEqual(
       graph.dependencies,
-      new Map([
+      new Map<number, readonly number[]>([
         [1, [3]],
         [2, [1]],
         [3, [1]],
@@ -65,7 +69,7 @@ describe(queueGraph, () => {
         member({ number: 3, body: 'Merge-After: #1' }),
       ],
       'main',
-      new Map([
+      new Map<number, readonly number[]>([
         [11, [12]],
         [12, [3]],
       ]),
@@ -73,7 +77,7 @@ describe(queueGraph, () => {
 
     assert.deepStrictEqual(
       graph.dependencies,
-      new Map([
+      new Map<number, readonly number[]>([
         [1, [2]],
         [2, [3]],
         [3, [1]],
@@ -82,7 +86,7 @@ describe(queueGraph, () => {
 
     assert.deepStrictEqual(
       graph.inherited,
-      new Map([
+      new Map<number, readonly number[]>([
         [1, [2]],
         [2, [3]],
         [3, []],
@@ -132,7 +136,7 @@ describe(queueStanding, () => {
     assert.deepStrictEqual(
       queueStanding(
         facts({ number: 1 }),
-        context({ owners: new Map([[1, owner]]) }),
+        context({ owners: new Map<number, QueueOwner>([[1, owner]]) }),
       ),
       { kind: 'owned', owner },
     );
@@ -142,7 +146,7 @@ describe(queueStanding, () => {
     assert.deepStrictEqual(
       queueStanding(
         facts({ number: 2, baseRef: 'feature/1' }),
-        context({ stackParents: new Map([[2, 1]]) }),
+        context({ stackParents: new Map<number, number>([[2, 1]]) }),
       ),
       { kind: 'stacked', on: 1, cyclic: false },
     );
@@ -184,8 +188,8 @@ describe(queueStanding, () => {
       queueStanding(
         pr,
         context({
-          dependencies: new Map([[2, [1]]]),
-          openNumbers: new Set([1, 2]),
+          dependencies: new Map<number, readonly number[]>([[2, [1]]]),
+          openNumbers: new Set<number>([1, 2]),
         }),
       ),
       { kind: 'waiting', on: [1], cyclic: false },
@@ -420,13 +424,13 @@ const member = (
 const context = (fields: Partial<QueueContext> = {}): QueueContext =>
   ({
     defaultBranch: 'main',
-    stackParents: new Map(),
-    dependencies: new Map(),
-    inherited: new Map(),
+    stackParents: new Map<number, number>(),
+    dependencies: new Map<number, readonly number[]>(),
+    inherited: new Map<number, readonly number[]>(),
     cycles: [],
-    cyclic: new Set(),
-    openNumbers: new Set(),
+    cyclic: new Set<number>(),
+    openNumbers: new Set<number>(),
     releaseBlockers: [],
-    owners: new Map(),
+    owners: new Map<number, QueueOwner>(),
     ...fields,
   }) as const;

package/src/queue-owner.mts

@@ -40,8 +40,9 @@ export const QUEUE_OWNERS = ['worker', 'skill', 'human', 'none'] as const;
 
 /**
  * `skill` is the `/unblock-prs` skill, which fixes every queued pull request
- * the worker sets aside — the dependency update's (`chore/pnpm-update`)
- * included.
+ * the worker sets aside — a branch the repository generates included, which
+ * it builds again rather than rebases (`generatedBranches` in
+ * `.github/unblock-prs.json`).
  */
 export type QueueOwner = Readonly<{
   owner: 'human' | 'none' | 'skill' | 'worker';
@@ -214,13 +215,7 @@ export const queueOwner = (pr: QueueOwnerInput): QueueOwner | undefined => {
   const handedOff = skillHandOff(pr, setAside.reason, queued);
 
   return handedOff === undefined
-    ? {
-        owner: 'skill',
-        reason:
-          setAside.reason === 'rebase-failed' && isPnpmUpdate(pr)
-            ? `${said}; the skill has \`pnpm-update.yml\` rebuild it from main`
-            : `${said}; ${why}`,
-      }
+    ? { owner: 'skill', reason: `${said}; ${why}` }
     : { owner: 'human', reason: `${said}: ${handedOff}` };
 };
 
@@ -274,15 +269,6 @@ export const isSetAsideReason = (reason: string): reason is SetAsideReason =>
 
 const KNOWN_REASONS: ReadonlySet<string> = new Set(SET_ASIDE_REASONS);
 
-/**
- * The dependency update, which `pnpm-update.yml` builds from the default
- * branch: a conflict on it is resolved by building it again, not by a rebase.
- */
-export const PNPM_UPDATE_BRANCH = 'chore/pnpm-update';
-
-const isPnpmUpdate = (pr: QueueOwnerInput): boolean =>
-  pr.headRef === PNPM_UPDATE_BRANCH;
-
 /**
  * Why nothing in the queue can move `pr` until a person does something, if
  * so: the worker passes these over with a note, and no skill takes them up.

package/src/queue-owner.test.mts

@@ -177,7 +177,7 @@ describe(queueOwner, () => {
     );
   });
 
-  test('gives the dependency update’s failure and its conflict to the skill', () => {
+  test('gives a generated branch’s failure and its conflict to the skill', () => {
     const update = { ...queued, headRef: 'chore/pnpm-update' } as const;
 
     assert.deepStrictEqual(
@@ -188,13 +188,13 @@ describe(queueOwner, () => {
       },
     );
 
-    // Not rebased by hand: the skill has `pnpm-update.yml` rebuild it.
+    // The same as for any other branch: which branches are generated, and
+    // how, is the repository's configuration, which the skill reads.
     assert.deepStrictEqual(
       queueOwner({ ...update, setAside: standing('rebase-failed') }),
       {
         owner: 'skill',
-        reason:
-          'set aside `rebase-failed` at its head; the skill has `pnpm-update.yml` rebuild it from main',
+        reason: 'set aside `rebase-failed` at its head; the skill fixes it',
       },
     );
   });

package/src/report.mts

@@ -9,6 +9,7 @@ import {
   decideStartStates,
   inheritStartAfter,
   issuesInProgress,
+  progressOf,
   withProgress,
   type ReferenceStatus,
 } from './start-after.mjs';
@@ -43,7 +44,7 @@ export const buildReport = ({
   issues,
   issuesLimit,
   issueDeclarations,
-  references = new Map(),
+  references = new Map<number, ReferenceStatus>(),
 }: Readonly<{
   repo: RepoRef;
   defaultBranch: string;
@@ -83,8 +84,8 @@ export const buildReport = ({
 
 /**
  * Each open issue with how it stands for being started
- * (`docs/issue-start-after.md`): its start state, or `in-progress` when it
- * is startable and an open pull request closes it, and where each thing it
+ * (`docs/issue-start-after.md`): its start state, or how far someone has
+ * got with it when it is startable (`progressOf`), and where each thing it
  * names stands.
  */
 const reportIssues = (
@@ -109,7 +110,7 @@ const reportIssues = (
     ...issue,
     start: withProgress(
       states.get(issue.number) ?? 'free',
-      worked.has(issue.number),
+      progressOf(issue.labels, worked.has(issue.number)),
     ),
     named: issue.startAfter.map((number) => ({
       number,
@@ -236,8 +237,8 @@ export const buildEntries = ({
 };
 
 const NO_DECLARATIONS: IssueDeclarations = {
-  startAfter: new Map(),
-  open: new Set(),
+  startAfter: new Map<number, readonly number[]>(),
+  open: new Set<number>(),
 } as const;
 
 /**

package/src/report.test.mts

@@ -1,4 +1,5 @@
 import { buildEntries, buildReport } from './report.mjs';
+import type { ReferenceStatus } from './start-after.mjs';
 import type {
   ContextState,
   LinkedIssue,
@@ -26,7 +27,7 @@ const facts = (
     updatedAt: '2026-09-26T00:00:00Z',
     headCommittedAt: undefined,
     comparison: undefined,
-    reported: new Map(),
+    reported: new Map<string, ContextState>(),
     checksRunning: false,
     linkedIssues: [],
     ...overrides,
@@ -103,8 +104,8 @@ describe(buildEntries, () => {
       issues: {
         // #11 waits for #12, which #2 is closing, and for the open #3; #13
         // is open and nobody has started it.
-        startAfter: new Map([[11, [12, 3, 13]]]),
-        open: new Set([11, 12, 13]),
+        startAfter: new Map<number, readonly number[]>([[11, [12, 3, 13]]]),
+        open: new Set<number>([11, 12, 13]),
       },
     });
 
@@ -153,7 +154,10 @@ describe(buildEntries, () => {
         }),
         facts(2),
       ],
-      issues: { startAfter: new Map([[11, [2]]]), open: new Set() },
+      issues: {
+        startAfter: new Map<number, readonly number[]>([[11, [2]]]),
+        open: new Set<number>(),
+      },
     });
 
     assert.deepStrictEqual(entries[0]?.inheritedMergeAfter, []);
@@ -169,7 +173,10 @@ describe(buildEntries, () => {
         facts(1, { linkedIssues: [linked(11, 'open')] }),
         facts(2, { body: 'Merge-After: #1' }),
       ],
-      issues: { startAfter: new Map([[11, [2]]]), open: new Set() },
+      issues: {
+        startAfter: new Map<number, readonly number[]>([[11, [2]]]),
+        open: new Set<number>(),
+      },
     });
 
     assert.deepStrictEqual(cycles, [[1, 2]]);
@@ -180,7 +187,10 @@ describe(buildEntries, () => {
       required: [],
       defaultBranch: 'main',
       pulls: [facts(1, { linkedIssues: [linked(11, 'closed')] }), facts(2)],
-      issues: { startAfter: new Map([[11, [2]]]), open: new Set() },
+      issues: {
+        startAfter: new Map<number, readonly number[]>([[11, [2]]]),
+        open: new Set<number>(),
+      },
     });
 
     assert.deepStrictEqual(entries[0]?.blockedBy, []);
@@ -309,7 +319,7 @@ describe(buildReport, () => {
         issue(4, [100, 101], [7]),
       ],
       issuesLimit: 30,
-      references: new Map([
+      references: new Map<number, ReferenceStatus>([
         [100, 'done'],
         [101, 'abandoned'],
       ]),
@@ -369,6 +379,36 @@ describe(buildReport, () => {
 
     assert.strictEqual(report.issues[0]?.start, 'attention');
   });
+
+  test('reads the in-progress and planned labels of a startable issue', () => {
+    const report = buildReport({
+      repo: { owner: 'o', name: 'r' },
+      defaultBranch: 'main',
+      generatedAt: '2026-10-24T00:00:00Z',
+      required: [],
+      authenticated: true,
+      pulls: [],
+      merged: [],
+      mergedWithinDays: 7,
+      issues: [
+        labelled(1, [], 'in-progress'),
+        labelled(2, [], 'planned'),
+        // Blocked says so, whatever is planned for it.
+        labelled(3, [1], 'planned'),
+      ],
+      issuesLimit: 30,
+      references: new Map<number, ReferenceStatus>(),
+    });
+
+    assert.deepStrictEqual(
+      report.issues.map(({ number, start }) => ({ number, start })),
+      [
+        { number: 1, start: 'in-progress' },
+        { number: 2, start: 'planned' },
+        { number: 3, start: 'blocked' },
+      ],
+    );
+  });
 });
 
 const issue = (
@@ -388,3 +428,13 @@ const issue = (
     startAfter,
     misplacedMergeAfter,
   }) as const;
+
+const labelled = (
+  number: number,
+  startAfter: readonly number[],
+  name: string,
+): OpenIssue =>
+  ({
+    ...issue(number, startAfter),
+    labels: [{ name, color: 'cccccc', description: '' }],
+  }) as const;

package/src/stack.test.mts

@@ -96,7 +96,7 @@ describe(findStackParents, () => {
 
 describe(stackDescendants, () => {
   test('every layer above, each after the one it is on', () => {
-    const parents = new Map([
+    const parents = new Map<number, number>([
       [2, 1],
       [3, 2],
       [4, 1],
@@ -114,7 +114,7 @@ describe(stackDescendants, () => {
     // Two pull requests opened onto each other's branches. Nothing lands
     // either, and the merge order reports it as a cycle; the walk only has to
     // stop.
-    const parents = new Map([
+    const parents = new Map<number, number>([
       [1, 2],
       [2, 1],
     ]);

package/src/start-after.mts

@@ -5,6 +5,7 @@
  */
 
 import { Arr } from 'ts-data-forge';
+import { IN_PROGRESS_LABEL, PLANNED_LABEL } from './labels.mjs';
 import { findMergeAfterCycles, parseStartAfter } from './merge-after.mjs';
 
 /**
@@ -48,19 +49,57 @@ export const waitsFor = (
 ): readonly number[] => Arr.uniq(parseStartAfter(body).concat(blockedBy));
 
 /**
- * How an issue is shown: its {@link StartState}, or `in-progress` when it is
- * startable and an open pull request closes it. Kept apart from the start
- * state in the rules (`docs/issue-start-after.md`): one that is blocked or
- * on a cycle says so whether or not someone has started it.
+ * How an issue is shown: its {@link StartState}, or how far someone has got
+ * with it when it is startable ({@link IssueProgress}). Kept apart from the
+ * start state in the rules (`docs/issue-start-after.md`): one that is blocked
+ * or on a cycle says so whether or not someone has started it.
  */
-export type IssueStartState = StartState | 'in-progress';
+export type IssueStartState = StartState | 'in-progress' | 'planned';
 
-/** The {@link IssueStartState} of an issue, given whether it is worked on. */
+/**
+ * How far someone has got with an issue, whatever it waits for:
+ *
+ * - `in-progress` — an open pull request closes it, or it is labelled
+ *   `in-progress` (`labels.mts`), which is how it says so before there is one.
+ * - `planned` — it is labelled `planned`: someone means to start it next.
+ * - `none` — neither.
+ */
+export type IssueProgress = 'in-progress' | 'none' | 'planned';
+
+/**
+ * The {@link IssueProgress} of an issue carrying `labels`, given whether an
+ * open pull request closes it. Being worked on wins over being planned: one
+ * carrying both was started without the plan being taken off.
+ */
+export const progressOf = (
+  labels: readonly Readonly<{ name: string }>[],
+  closedByOpenPull: boolean,
+): IssueProgress =>
+  closedByOpenPull || hasLabel(labels, IN_PROGRESS_LABEL)
+    ? 'in-progress'
+    : hasLabel(labels, PLANNED_LABEL)
+      ? 'planned'
+      : 'none';
+
+/**
+ * Whether `labels` holds `name`, whatever its case. GitHub's label names
+ * are: adding `in-progress` to a repository that has `In-Progress` puts that
+ * one on, so an exact match would not see the label it just added.
+ */
+export const hasLabel = (
+  labels: readonly Readonly<{ name: string }>[],
+  name: string,
+): boolean =>
+  labels.some((label) => label.name.toLowerCase() === name.toLowerCase());
+
+/** The {@link IssueStartState} of an issue, given how far it has got. */
 export const withProgress = (
   state: StartState,
-  worked: boolean,
+  progress: IssueProgress,
 ): IssueStartState =>
-  worked && (state === 'free' || state === 'ready') ? 'in-progress' : state;
+  progress !== 'none' && (state === 'free' || state === 'ready')
+    ? progress
+    : state;
 
 /** The issues an open pull request closes: the ones being worked on. */
 export const issuesInProgress = (