@oss-autopilot/core 3.4.1 → 3.6.0

package/dist/core/extraction-categories.js

@@ -0,0 +1,108 @@
+/**
+ * Per-repo extraction category configuration (#1284).
+ *
+ * The `extract-learnings` MCP prompt produces a structured markdown
+ * document organized into category sections. The default category
+ * set is sensible for typical web/library OSS work; specialized
+ * repos (security-focused, performance-critical, accessibility-
+ * forward) benefit from a tailored taxonomy.
+ *
+ * This module is the single source of truth for:
+ *   - The default category list.
+ *   - Validation of custom category lists (non-empty, no duplicates,
+ *     reasonable string lengths).
+ *   - Resolution: given a repo's optional override, produce the list
+ *     of categories the prompt and the storage layer should use.
+ *
+ * Pure typed helper — no I/O. Same architectural shape as the recent
+ * #1252 / #1264 / #1286 / #1279 / #1277 extractions.
+ *
+ * Out of scope (deferred per #1284):
+ *  - Wiring `categories` into the `guidelines store` / `guidelines view`
+ *    shape so the override persists alongside the markdown.
+ *  - Updating the `extract-learnings` MCP prompt to consume the
+ *    resolved category list at run time.
+ *  - Detecting repo type from signals (SECURITY.md presence, repo
+ *    topics, etc.) to suggest categories.
+ */
+/**
+ * The default category list used by `extract-learnings` when no
+ * per-repo override is configured. Order matters: the prompt
+ * renders sections in this order, so `Code Style` first /
+ * `Other` last is the established convention.
+ */
+export const DEFAULT_EXTRACTION_CATEGORIES = [
+    'Code Style',
+    'Process',
+    'Architecture',
+    'Testing',
+    'Other',
+];
+/**
+ * Reasonable bounds on an override list. The prompt produces output
+ * organized into one heading per category; very long lists become
+ * unreadable, very long category names blow out heading width.
+ */
+const CATEGORY_NAME_MAX_LENGTH = 40;
+const MAX_CATEGORIES = 12;
+/**
+ * Validate a user-supplied category list. Returns a structured
+ * result rather than throwing — the CLI / slash-command callers
+ * surface error strings inline.
+ */
+export function validateCategories(input) {
+    const errors = [];
+    if (input.length === 0) {
+        errors.push('At least one category is required.');
+        return { ok: false, errors };
+    }
+    if (input.length > MAX_CATEGORIES) {
+        errors.push(`At most ${MAX_CATEGORIES} categories are supported (received ${input.length}).`);
+    }
+    const seen = new Set();
+    const cleaned = [];
+    for (const raw of input) {
+        const trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            errors.push('Category names cannot be empty or whitespace-only.');
+            continue;
+        }
+        if (trimmed.length > CATEGORY_NAME_MAX_LENGTH) {
+            errors.push(`Category "${trimmed.slice(0, 30)}…" is longer than ${CATEGORY_NAME_MAX_LENGTH} characters.`);
+            continue;
+        }
+        const lowerKey = trimmed.toLowerCase();
+        if (seen.has(lowerKey)) {
+            errors.push(`Duplicate category "${trimmed}" (case-insensitive).`);
+            continue;
+        }
+        seen.add(lowerKey);
+        cleaned.push(trimmed);
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    // Always ensure an "Other" bucket exists at the end so the prompt
+    // has a place to put feedback that doesn't fit the user's chosen
+    // categories. Append silently if missing rather than treating the
+    // omission as an error — most users won't think to add it.
+    if (!seen.has('other')) {
+        cleaned.push('Other');
+    }
+    return { ok: true, errors: [], normalized: cleaned };
+}
+/**
+ * Resolve the categories the prompt + storage layer should use for a
+ * specific extraction. Falls back to the default list when no
+ * override is supplied or when the override fails validation.
+ */
+export function resolveCategories(override) {
+    if (!override || override.length === 0) {
+        return DEFAULT_EXTRACTION_CATEGORIES;
+    }
+    const result = validateCategories(override);
+    if (!result.ok || !result.normalized) {
+        return DEFAULT_EXTRACTION_CATEGORIES;
+    }
+    return result.normalized;
+}

package/dist/core/follow-up-history.d.ts

@@ -0,0 +1,41 @@
+/**
+ * PR follow-up history helpers (#1277).
+ *
+ * Centralizes the read/write logic for `state.prFollowUpHistory`.
+ * Used by `workflows/dormant-pr-follow-up.md` to enforce the
+ * one-follow-up-per-timeframe rule documented in
+ * `skills/pr-etiquette/SKILL.md`.
+ *
+ * Pure functions — callers manage state I/O.
+ */
+import type { AgentState } from './state-schema.js';
+import type { FollowUpEntry } from './state-schema.js';
+export type FollowUpTier = 'light_check_in' | 'direct_check_in' | 'final_check_in';
+/**
+ * Tier window in days. The "no second ping in the same window" rule
+ * uses this to decide whether a recent follow-up still locks out the
+ * next draft. Sourced from `skills/pr-etiquette/SKILL.md`.
+ */
+export declare const TIER_WINDOW_DAYS: Record<FollowUpTier, number>;
+/**
+ * Read the existing follow-up entries for a PR. Returns an empty
+ * array when no entries exist or when the state field is unset.
+ */
+export declare function getFollowUpHistory(state: AgentState, prUrl: string): FollowUpEntry[];
+/**
+ * Find the most recent entry, or null when there are none. Used by
+ * the workflow's pre-draft gate.
+ */
+export declare function lastFollowUp(state: AgentState, prUrl: string): FollowUpEntry | null;
+/**
+ * Whether a follow-up of the given tier was drafted within the
+ * tier's own window. The workflow uses this to surface a warning
+ * before the user drafts a second ping in the same window. Different
+ * tiers are always allowed (escalating light → direct → final).
+ */
+export declare function isWithinTierWindow(state: AgentState, prUrl: string, tier: FollowUpTier, now?: Date): boolean;
+/**
+ * Record a new follow-up entry. Returns the next state; callers
+ * decide when to persist.
+ */
+export declare function recordFollowUp(state: AgentState, prUrl: string, entry: FollowUpEntry): AgentState;

package/dist/core/follow-up-history.js

@@ -0,0 +1,71 @@
+/**
+ * PR follow-up history helpers (#1277).
+ *
+ * Centralizes the read/write logic for `state.prFollowUpHistory`.
+ * Used by `workflows/dormant-pr-follow-up.md` to enforce the
+ * one-follow-up-per-timeframe rule documented in
+ * `skills/pr-etiquette/SKILL.md`.
+ *
+ * Pure functions — callers manage state I/O.
+ */
+/**
+ * Tier window in days. The "no second ping in the same window" rule
+ * uses this to decide whether a recent follow-up still locks out the
+ * next draft. Sourced from `skills/pr-etiquette/SKILL.md`.
+ */
+export const TIER_WINDOW_DAYS = {
+    light_check_in: 7,
+    direct_check_in: 14,
+    final_check_in: 30,
+};
+/**
+ * Read the existing follow-up entries for a PR. Returns an empty
+ * array when no entries exist or when the state field is unset.
+ */
+export function getFollowUpHistory(state, prUrl) {
+    return state.prFollowUpHistory?.[prUrl] ?? [];
+}
+/**
+ * Find the most recent entry, or null when there are none. Used by
+ * the workflow's pre-draft gate.
+ */
+export function lastFollowUp(state, prUrl) {
+    const entries = getFollowUpHistory(state, prUrl);
+    if (entries.length === 0)
+        return null;
+    // Newest by timestamp wins. Defensive sort because the persistence
+    // path doesn't guarantee insertion order across machines.
+    return [...entries].sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp))[0];
+}
+/**
+ * Whether a follow-up of the given tier was drafted within the
+ * tier's own window. The workflow uses this to surface a warning
+ * before the user drafts a second ping in the same window. Different
+ * tiers are always allowed (escalating light → direct → final).
+ */
+export function isWithinTierWindow(state, prUrl, tier, now = new Date()) {
+    const last = lastFollowUp(state, prUrl);
+    if (!last)
+        return false;
+    if (last.tier !== tier)
+        return false;
+    const ageMs = now.getTime() - Date.parse(last.timestamp);
+    if (Number.isNaN(ageMs))
+        return false;
+    const windowMs = TIER_WINDOW_DAYS[tier] * 86400000;
+    return ageMs < windowMs;
+}
+/**
+ * Record a new follow-up entry. Returns the next state; callers
+ * decide when to persist.
+ */
+export function recordFollowUp(state, prUrl, entry) {
+    const next = {
+        ...state,
+        prFollowUpHistory: { ...(state.prFollowUpHistory ?? {}) },
+    };
+    const list = next.prFollowUpHistory[prUrl] ? [...next.prFollowUpHistory[prUrl]] : [];
+    list.push(entry);
+    next.prFollowUpHistory[prUrl] = list;
+    return next;
+}

package/dist/core/gist-state-store.d.ts

@@ -14,7 +14,7 @@
  *  6. Cache all Gist file contents in memory for session-scoped reads
  *  7. Write state to a local cache file for fallback
  *
- * Concurrency model (#1115):
+ * Concurrency model (#1115, #1235):
  *
  *  Each fetch captures the response's `ETag` and stores it as
  *  `lastFetchedEtag`. The next `push()` sends that ETag back as
@@ -24,12 +24,25 @@
  *  On 412, the store attempts a single merge: it re-fetches the Gist
  *  (refreshing the ETag), re-applies the in-memory dirty content on top of
  *  the now-current remote state, and pushes once more. If that second push
- *  also returns 412, `push()` throws {@link GistConcurrencyError} — local
- *  mutations stay in memory so the caller can decide whether to refresh and
- *  retry. The merge step is intentionally cheap (state is a single JSON
- *  blob) and treats local dirty changes as authoritative for conflict
- *  cells, which matches the "last-write-wins by intent" model the rest of
- *  oss-autopilot already assumes for state.json.
+ *  also returns 412, `push()` throws {@link GistConcurrencyError}.
+ *
+ *  Per-file conflict policy on the merge re-apply step:
+ *
+ *   - `state.json` is fail-loud. The `StateManager` contract advertises
+ *     optimistic compare-and-swap (state.ts:285-296), so silently clobbering
+ *     a concurrent remote write would violate it. To detect concurrent
+ *     writes without per-file ETags (the Gist API only exposes one ETag for
+ *     the whole gist), we snapshot each file's content at fetch time. If
+ *     the post-refresh `state.json` differs from the snapshot we held
+ *     before the refresh, another machine wrote it: `push()` throws
+ *     `GistConcurrencyError` instead of overwriting.
+ *   - Freeform documents (e.g. per-repo guidelines) keep last-write-wins.
+ *     The `setDocument` / `setGuidelines` callers' intent on a manual write
+ *     is "overwrite". Local dirty content is reapplied on top of the
+ *     refreshed remote.
+ *
+ *  In both cases, when the second push also 412s, local mutations stay in
+ *  memory so the caller can decide whether to refresh and retry.
  */
 import { AgentState } from './types.js';
 /** Well-known Gist description used for search-based discovery. */
@@ -126,6 +139,16 @@ export declare class GistStateStore {
     private gistId;
     readonly cachedFiles: Map<string, string>;
     readonly dirtyFiles: Set<string>;
+    /**
+     * Per-file content snapshot captured at fetch time (#1235). The Gist API
+     * exposes a single ETag for the whole gist, so we cannot use `If-Match`
+     * to detect a per-file conflict on the 412 merge re-apply. Holding the
+     * baseline content lets us compare it against the freshly-fetched remote
+     * and decide whether `state.json` changed under us. Updated only by
+     * `fetchAndCache` and successful `push()`; not mutated by `setState` /
+     * `setDocument` so the baseline reflects the remote, not local edits.
+     */
+    private baselineFiles;
     /**
      * ETag captured from the most recent successful Gist fetch (#1115).
      * Sent back as `If-Match` on `update` so concurrent writes from another

package/dist/core/gist-state-store.js

@@ -14,7 +14,7 @@
  *  6. Cache all Gist file contents in memory for session-scoped reads
  *  7. Write state to a local cache file for fallback
  *
- * Concurrency model (#1115):
+ * Concurrency model (#1115, #1235):
  *
  *  Each fetch captures the response's `ETag` and stores it as
  *  `lastFetchedEtag`. The next `push()` sends that ETag back as
@@ -24,12 +24,25 @@
  *  On 412, the store attempts a single merge: it re-fetches the Gist
  *  (refreshing the ETag), re-applies the in-memory dirty content on top of
  *  the now-current remote state, and pushes once more. If that second push
- *  also returns 412, `push()` throws {@link GistConcurrencyError} — local
- *  mutations stay in memory so the caller can decide whether to refresh and
- *  retry. The merge step is intentionally cheap (state is a single JSON
- *  blob) and treats local dirty changes as authoritative for conflict
- *  cells, which matches the "last-write-wins by intent" model the rest of
- *  oss-autopilot already assumes for state.json.
+ *  also returns 412, `push()` throws {@link GistConcurrencyError}.
+ *
+ *  Per-file conflict policy on the merge re-apply step:
+ *
+ *   - `state.json` is fail-loud. The `StateManager` contract advertises
+ *     optimistic compare-and-swap (state.ts:285-296), so silently clobbering
+ *     a concurrent remote write would violate it. To detect concurrent
+ *     writes without per-file ETags (the Gist API only exposes one ETag for
+ *     the whole gist), we snapshot each file's content at fetch time. If
+ *     the post-refresh `state.json` differs from the snapshot we held
+ *     before the refresh, another machine wrote it: `push()` throws
+ *     `GistConcurrencyError` instead of overwriting.
+ *   - Freeform documents (e.g. per-repo guidelines) keep last-write-wins.
+ *     The `setDocument` / `setGuidelines` callers' intent on a manual write
+ *     is "overwrite". Local dirty content is reapplied on top of the
+ *     refreshed remote.
+ *
+ *  In both cases, when the second push also 412s, local mutations stay in
+ *  memory so the caller can decide whether to refresh and retry.
  */
 import * as fs from 'node:fs';
 import { AgentStateSchema } from './state-schema.js';
@@ -77,6 +90,16 @@ export class GistStateStore {
     gistId = null;
     cachedFiles = new Map();
     dirtyFiles = new Set();
+    /**
+     * Per-file content snapshot captured at fetch time (#1235). The Gist API
+     * exposes a single ETag for the whole gist, so we cannot use `If-Match`
+     * to detect a per-file conflict on the 412 merge re-apply. Holding the
+     * baseline content lets us compare it against the freshly-fetched remote
+     * and decide whether `state.json` changed under us. Updated only by
+     * `fetchAndCache` and successful `push()`; not mutated by `setState` /
+     * `setDocument` so the baseline reflects the remote, not local edits.
+     */
+    baselineFiles = new Map();
     /**
      * ETag captured from the most recent successful Gist fetch (#1115).
      * Sent back as `If-Match` on `update` so concurrent writes from another
@@ -379,17 +402,61 @@ export class GistStateStore {
                 if (content !== undefined)
                     stagedContents[filename] = content;
             }
+            // Snapshot the full cache and baseline before refresh so a partial
+            // failure inside fetchAndCache (e.g. parse throws after the cache
+            // was already cleared and repopulated) can be rolled back without
+            // leaving the store with a stale ETag pointing at corrupt or
+            // half-populated state (#1235).
+            const preRefreshCache = new Map(this.cachedFiles);
+            const preRefreshBaseline = new Map(this.baselineFiles);
+            const preRefreshEtag = this.lastFetchedEtag;
+            const reapplyStaged = () => {
+                for (const [filename, content] of Object.entries(stagedContents)) {
+                    this.cachedFiles.set(filename, content);
+                }
+            };
             try {
                 await this.fetchAndCache(this.gistId);
             }
             catch (refreshErr) {
                 warn(MODULE, `Merge refresh after 412 failed: ${refreshErr}`);
+                // Roll back any partial mutation from fetchAndCache so the
+                // caller's retry path sees the prior state (with local
+                // mutations re-applied on top).
+                this.cachedFiles.clear();
+                for (const [filename, content] of preRefreshCache) {
+                    this.cachedFiles.set(filename, content);
+                }
+                this.baselineFiles = preRefreshBaseline;
+                this.lastFetchedEtag = preRefreshEtag;
+                reapplyStaged();
+                // Preserve the GistCorruptError type so callers don't retry
+                // against a corrupt remote (which a CONCURRENCY_ERROR would
+                // invite). Other failure types continue to surface as a
+                // concurrency error — the gist content is still likely fine.
+                if (refreshErr instanceof GistCorruptError)
+                    throw refreshErr;
                 throw new GistConcurrencyError(expectedEtag, null);
             }
-            // Re-apply our staged dirty contents on top of the refreshed remote.
-            for (const [filename, content] of Object.entries(stagedContents)) {
-                this.cachedFiles.set(filename, content);
+            // Per-file conflict policy (#1235):
+            //  - state.json must fail loud when its remote copy moved under us;
+            //    silently overwriting would violate the StateManager
+            //    optimistic-concurrency contract (state.ts:285-296).
+            //  - Freeform documents (guidelines, etc.) keep last-write-wins —
+            //    `setDocument` callers' intent on a manual write is "overwrite".
+            if (stagedContents[STATE_FILE_NAME] !== undefined) {
+                const baselineBeforeRefresh = preRefreshBaseline.get(STATE_FILE_NAME);
+                const remoteAfterRefresh = this.cachedFiles.get(STATE_FILE_NAME);
+                if (baselineBeforeRefresh !== remoteAfterRefresh) {
+                    warn(MODULE, 'state.json changed remotely while a push was in flight; surfacing GistConcurrencyError instead of clobbering (#1235)');
+                    // Preserve local state.json (and other staged dirty files) in
+                    // memory so the caller can refresh and reapply if appropriate.
+                    reapplyStaged();
+                    throw new GistConcurrencyError(expectedEtag, this.lastFetchedEtag);
+                }
             }
+            // Re-apply our staged dirty contents on top of the refreshed remote.
+            reapplyStaged();
             result = await attempt(this.lastFetchedEtag);
             if (!result.ok && result.status === 412) {
                 warn(MODULE, 'Second push after merge also returned 412; surfacing GistConcurrencyError');
@@ -405,8 +472,11 @@ export class GistStateStore {
                 return false;
             }
         }
-        // Success: flush dirty set and write local cache
+        // Success: flush dirty set and write local cache. Refresh the
+        // per-file baseline to reflect what we just wrote — the next 412
+        // merge re-apply check compares against this.
         this.dirtyFiles.clear();
+        this.baselineFiles = new Map(this.cachedFiles);
         const raw = this.cachedFiles.get(STATE_FILE_NAME);
         if (raw) {
             try {
@@ -489,6 +559,10 @@ export class GistStateStore {
                 this.cachedFiles.set(filename, file.content);
             }
         }
+        // Snapshot the just-fetched contents as the per-file baseline (#1235).
+        // The 412 merge path uses this to detect whether a concurrent write
+        // changed `state.json` between this fetch and the next push attempt.
+        this.baselineFiles = new Map(this.cachedFiles);
         // Parse state.json
         const state = this.parseStateFromCache();
         // Write-through to local cache for degraded-mode fallback
@@ -578,6 +652,7 @@ export class GistStateStore {
                 this.cachedFiles.set(filename, file.content);
             }
         }
+        this.baselineFiles = new Map(this.cachedFiles);
         // Write-through to local cache
         this.writeLocalStateCache(freshState);
         return { id: data.id, state: freshState };
@@ -602,6 +677,7 @@ export class GistStateStore {
                 this.cachedFiles.set(filename, file.content);
             }
         }
+        this.baselineFiles = new Map(this.cachedFiles);
         // Write-through to local cache
         this.writeLocalStateCache(seedState);
         return { id: data.id, state: seedState };

package/dist/core/issue-conversation.js

@@ -205,6 +205,7 @@ export class IssueConversationMonitor {
             title: item.title,
             url: item.html_url,
             userLastCommentedAt: userLastComment.createdAt,
+            userLastCommentBody: userLastComment.body.slice(0, 200) + (userLastComment.body.length > 200 ? '...' : ''),
             labels,
             daysSinceUserComment: daysBetween(userLastCommentTime, new Date()),
         };

package/dist/core/issue-effort.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Action-menu issue effort classification (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt truth table so
+ * the rules are typed, unit-testable, and tunable without editing
+ * markdown. Same architectural shape as the typed-core extractions in
+ * #1245 (compliance-score), #1242 (repo-vet), #1243 (strategy), and
+ * #1252 (pr-quality-rubric).
+ */
+/** Issue types the action menu surfaces. Match the strings the CLI emits in
+ * `data.daily.actionableIssues[*].type`. */
+export type ActionableIssueType = 'needs_response' | 'needs_changes' | 'incomplete_checklist' | 'ci_failing' | 'merge_conflict';
+export type IssueEffort = 'small' | 'medium' | 'large';
+/**
+ * Decide the effort label for an actionable issue based on its type and
+ * how many maintainer hints accompany it. Default falls through to
+ * `medium` for any unrecognized combination — the action-menu workflow
+ * still renders something useful when the CLI surfaces a new issue
+ * type before this function is updated.
+ *
+ * Truth table sourced verbatim from `workflows/action-menu.md`:
+ *
+ * | Effort | Condition |
+ * |--------|-----------|
+ * | small  | needs_response with 0-1 hints, incomplete_checklist |
+ * | medium | needs_response with 2+ hints, needs_changes with 0-2 hints, ci_failing |
+ * | large  | merge_conflict, needs_changes with 3+ hints |
+ */
+export declare function computeIssueEffort(type: ActionableIssueType, hintCount: number): IssueEffort;

package/dist/core/issue-effort.js

@@ -0,0 +1,41 @@
+/**
+ * Action-menu issue effort classification (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt truth table so
+ * the rules are typed, unit-testable, and tunable without editing
+ * markdown. Same architectural shape as the typed-core extractions in
+ * #1245 (compliance-score), #1242 (repo-vet), #1243 (strategy), and
+ * #1252 (pr-quality-rubric).
+ */
+/**
+ * Decide the effort label for an actionable issue based on its type and
+ * how many maintainer hints accompany it. Default falls through to
+ * `medium` for any unrecognized combination — the action-menu workflow
+ * still renders something useful when the CLI surfaces a new issue
+ * type before this function is updated.
+ *
+ * Truth table sourced verbatim from `workflows/action-menu.md`:
+ *
+ * | Effort | Condition |
+ * |--------|-----------|
+ * | small  | needs_response with 0-1 hints, incomplete_checklist |
+ * | medium | needs_response with 2+ hints, needs_changes with 0-2 hints, ci_failing |
+ * | large  | merge_conflict, needs_changes with 3+ hints |
+ */
+export function computeIssueEffort(type, hintCount) {
+    const hints = Math.max(0, hintCount);
+    switch (type) {
+        case 'needs_response':
+            return hints <= 1 ? 'small' : 'medium';
+        case 'incomplete_checklist':
+            return 'small';
+        case 'needs_changes':
+            return hints >= 3 ? 'large' : 'medium';
+        case 'ci_failing':
+            return 'medium';
+        case 'merge_conflict':
+            return 'large';
+        default:
+            return 'medium';
+    }
+}

package/dist/core/maintainer-hints.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Maintainer-hint label constants (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt mapping so the
+ * label strings live in typed code instead of markdown. Adding a new
+ * hint type becomes a single-file change in core; the workflow gets
+ * the new label for free instead of requiring a parallel markdown
+ * edit. Same pattern as #1252.
+ */
+export type MaintainerHint = 'demo_requested' | 'tests_requested' | 'changes_requested' | 'docs_requested' | 'rebase_requested';
+/**
+ * Display labels the action-menu workflow renders for each hint type.
+ * Source of truth — both `data.daily.actionableIssues[*].maintainerHintsLabel`
+ * (computed by the CLI) and the workflow's prose docs reference this map.
+ */
+export declare const MAINTAINER_HINT_LABELS: Record<MaintainerHint, string>;
+/**
+ * Format an array of hints as a comma-joined human label, in the same
+ * order the caller passed them. Unknown hint values are dropped silently —
+ * a future CLI version might emit a hint type the workflow doesn't yet
+ * know about; rendering "undefined" would be worse than omitting it.
+ */
+export declare function formatMaintainerHints(hints: readonly MaintainerHint[] | readonly string[]): string;

package/dist/core/maintainer-hints.js

@@ -0,0 +1,36 @@
+/**
+ * Maintainer-hint label constants (#1264).
+ *
+ * Extracted from `workflows/action-menu.md`'s in-prompt mapping so the
+ * label strings live in typed code instead of markdown. Adding a new
+ * hint type becomes a single-file change in core; the workflow gets
+ * the new label for free instead of requiring a parallel markdown
+ * edit. Same pattern as #1252.
+ */
+/**
+ * Display labels the action-menu workflow renders for each hint type.
+ * Source of truth — both `data.daily.actionableIssues[*].maintainerHintsLabel`
+ * (computed by the CLI) and the workflow's prose docs reference this map.
+ */
+export const MAINTAINER_HINT_LABELS = {
+    demo_requested: 'demo/screenshot requested',
+    tests_requested: 'tests requested',
+    changes_requested: 'code changes requested',
+    docs_requested: 'documentation requested',
+    rebase_requested: 'rebase requested',
+};
+/**
+ * Format an array of hints as a comma-joined human label, in the same
+ * order the caller passed them. Unknown hint values are dropped silently —
+ * a future CLI version might emit a hint type the workflow doesn't yet
+ * know about; rendering "undefined" would be worse than omitting it.
+ */
+export function formatMaintainerHints(hints) {
+    const labels = [];
+    for (const h of hints) {
+        const label = MAINTAINER_HINT_LABELS[h];
+        if (label)
+            labels.push(label);
+    }
+    return labels.join(', ');
+}

package/dist/core/pr-monitor.d.ts

@@ -15,7 +15,7 @@
 import { FetchedPR, DailyDigest, ClosedPR, MergedPR, StarFilter } from './types.js';
 import { type PRCountsResult } from './github-stats.js';
 export { computeDisplayLabel } from './display-utils.js';
-export { classifyCICheck, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
+export { categorizeCIStatus, classifyCICheck, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
 export { determineStatus } from './status-determination.js';
 /**