loreli 1.0.0 → 2.0.0

package/packages/knowledge/README.md

@@ -1,13 +1,13 @@
 # loreli/knowledge
 
-Knowledge capture engine — the write path. Classifies review and plan feedback, detects recurring patterns across PRs and discussions, proposes promotions via GitHub Discussions with smart target suggestions, and applies approved promotions by creating action issues.
+Knowledge capture engine — the write path. Classifies review and plan feedback via LLM, detects recurring patterns across PRs and discussions, and formats patterns into planning objectives for downstream tools.
 
 ## Overview
 
-The knowledge package closes the feedback loop in Loreli's agentic workflow. Review comments and plan verdict feedback are classified into categories, aggregated across PRs and discussions, and when recurring patterns emerge, promoted into permanent standards — AGENTS.md, custom prompts, or other configuration.
+The knowledge package closes the feedback loop in Loreli's agentic workflow. Review comments and plan verdict feedback are classified into categories via LLM, aggregated across PRs and discussions, and when recurring patterns emerge, converted to objectives via `objective()` and routed through `planner.plan()`.
 
 ```text
-classify → patterns → propose → [human approval] → apply
+classify → patterns → objective → planner.plan()
 ```
 
 Feedback is captured from two sources:
@@ -15,41 +15,84 @@ Feedback is captured from two sources:
 - **PR reviews** — `forward()` in `loreli/review` classifies `REQUEST_CHANGES` feedback and posts a `loreli:feedback` marker with `source="pr"` on the PR.
 - **Plan verdicts** — The `plan/verdict` action classifies `changes-requested` feedback and posts a `loreli:feedback` marker with `source="plan"` on the discussion.
 
+All classification is LLM-powered via `loreli/classify`. Both `classify()` and `classifyRefs()` delegate to on-disk prompt templates — there are no regex heuristics or keyword fallbacks.
+
 ## API Reference
 
-### `classify(feedback, opts?)`
+### `classify(feedback, opts)`
 
-Categorize feedback text into a category using keyword heuristics. Each category has a set of regex patterns (see [Configuration](#configuration) for the full list). The text is scored against every allowed category, and the highest-scoring category wins.
+Categorize feedback text into a category via LLM. Delegates to `loreli/classify` using the `feedback` prompt template, which defines six categories: naming, architecture, testing, documentation, performance, security.
 
 **Parameters:**
 
 | Name | Type | Description |
 |------|------|-------------|
 | `feedback` | `string` | Review or verdict comment text. |
-| `opts.categories` | `string[]` | Restrict classification to only these categories. When provided, categories not in this list are never scored — even if the text contains matching keywords. Defaults to all six built-in categories. |
+| `opts.backends` | `BackendRegistry` | **Required.** Backend registry for LLM classification. |
+| `opts.config` | `Config` | Config instance for model/timeout resolution. |
+
+**Returns:** `Promise<{ category: string, confidence: number }>`
 
-**Returns:** `{ category: string, confidence: number }`
+- `category` — One of: `naming`, `architecture`, `testing`, `documentation`, `performance`, `security`.
+- `confidence` — `0.0` to `1.0` as returned by the LLM. Defaults to `0.8` when the LLM omits it.
 
-- `category` — The highest-scoring category from the allowed set. When no keywords match anything, defaults to `documentation`.
-- `confidence` — `0` to `1`. Each keyword match adds `1/3` to confidence (capped at `1.0`). Zero means no keywords matched.
+**Throws:** When `backends` is missing or the LLM call fails. Callers must wrap in `try/catch`.
 
 The following example classifies a review comment about naming conventions:
 
 ```js
 import { classify } from 'loreli/knowledge';
 
-const { category, confidence } = classify(
-  'The naming convention should follow camelCase for consistency'
+const { category, confidence } = await classify(
+  'The naming convention should follow camelCase for consistency',
+  { backends: backendRegistry }
 );
-// category: 'naming', confidence: 0.67
+// category: 'naming', confidence: 0.85
 ```
 
-When categories are restricted, matching keywords outside the allowed set are ignored. This is how the `feedback.categories` config restricts what gets captured during PR reviews:
+### `extractRefs(comments)`
+
+Extract unique `#N` references from discussion comment bodies.
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `comments` | `Array<{ body: string }>` | Discussion comments. |
+
+**Returns:** `number[]` — Unique referenced numbers.
+
+### `classifyRefs(comments, refs, opts)`
+
+Classify extracted references as blockers or informational via LLM. Delegates to `loreli/classify` using the `blocker` prompt template, which performs per-reference classification — each ref is individually classified as either a blocking dependency or an informational reference.
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `comments` | `Array<{ body: string, author?: string }>` | Discussion comments containing the refs. |
+| `refs` | `number[]` | Extracted reference numbers from `extractRefs()`. |
+| `opts.backends` | `BackendRegistry` | **Required.** Backend registry for LLM classification. |
+| `opts.config` | `Config` | Config instance for model/timeout resolution. |
+
+**Returns:** `Promise<{ blockers: number[], references: number[] }>`
+
+Returns immediately with empty arrays when `refs` is empty (no LLM call made).
+
+**Throws:** When `backends` is missing or the LLM call fails. Callers must wrap in `try/catch`.
+
+The following example classifies references from a plan discussion where `#5` is a blocker and `#6` is informational:
 
 ```js
-classify('Missing test coverage', { categories: ['naming', 'security'] });
-// category: 'naming' (or 'security'), confidence: 0
-// 'testing' keywords match but 'testing' is not in the allowed list
+import { classifyRefs, extractRefs } from 'loreli/knowledge';
+
+const comments = [
+  { body: 'Blocked by #5', author: 'reviewer' },
+  { body: 'See #6 for context', author: 'reviewer' }
+];
+const refs = extractRefs(comments);
+const result = await classifyRefs(comments, refs, { backends: backendRegistry });
+// { blockers: [5], references: [6] }
 ```
 
 ### `patterns(hub, repo, opts?)`
@@ -89,83 +132,29 @@ The `type` discriminator on each ref distinguishes whether the feedback originat
 
 Cross-provider patterns (multiple providers flagging the same category) lower the effective threshold by 1.
 
-### `propose(hub, repo, pattern)`
-
-Create a promotion discussion for a detected pattern. The discussion is created in the repo's "Loreli" discussion category with a `loreli:promotion` marker and a structured template.
-
-**Parameters:**
-
-| Name | Type | Description |
-|------|------|-------------|
-| `hub` | `object` | Hub instance with `category` and `discuss` methods. |
-| `repo` | `string` | `"owner/name"` repository. |
-| `pattern` | `Pattern` | A pattern object from `patterns()`. |
-
-**Returns:** `Promise<{ number: number, id: string, url: string }>`
+### `objective(pattern)`
 
-The generated discussion body includes:
-
-1. **Smart target suggestion** — The most likely promotion target is pre-checked based on feedback source distribution:
-   - Discussion-dominated feedback suggests the **Planner prompt** (`.loreli/planner.md`)
-   - PR-dominated feedback suggests the **Action prompt** (`.loreli/action.md`)
-   - Evenly mixed feedback suggests **AGENTS.md**
-2. **Mixed ref formatting** — Refs are prefixed with `PR #N` or `Discussion #N` based on their type.
-3. **Clear human instructions** — The Decision section tells the human to check one option and close the discussion to trigger the promotion pipeline.
-
-Available promotion targets:
-
-| Target | File Path | Use Case |
-|--------|-----------|----------|
-| AGENTS.md | `AGENTS.md` | Universal coding convention |
-| Planner prompt | `.loreli/planner.md` | Planning standards |
-| Reviewer prompt | `.loreli/review.md` | Review criteria |
-| Action prompt | `.loreli/action.md` | Implementation guidance |
-| Risk prompt | `.loreli/risk.md` | Risk assessment criteria |
-
-### `apply(hub, repo, promotion)`
-
-Execute an approved promotion by creating an action issue. Parses the selected target checkbox from the promotion discussion body and includes the concrete file path in the issue.
-
-**Parameters:**
-
-| Name | Type | Description |
-|------|------|-------------|
-| `hub` | `object` | Hub instance with `open` method. |
-| `repo` | `string` | `"owner/name"` repository. |
-| `promotion.summary` | `string` | Pattern summary for the issue title. |
-| `promotion.discussion` | `number` | Source discussion number. |
-| `promotion.body` | `string` | Full promotion discussion body (used to extract the selected target). |
-
-**Returns:** `Promise<{ number: number, url: string }>`
-
-The created issue includes a `## Target` section with `**Target file**` pointing to the concrete path (e.g., `.loreli/action.md`), a `## Change` section with the promotion body, and a `## Reference` linking back to the discussion.
-
-If no target checkbox is checked, defaults to `AGENTS.md`.
-
-### `extractRefs(comments)`
-
-Extract unique `#N` references from discussion comment bodies.
+Formats a detected feedback pattern into a planning objective string. Embeds a `loreli:feedback` marker so downstream tools can auto-detect the feedback category.
 
 **Parameters:**
 
 | Name | Type | Description |
 |------|------|-------------|
-| `comments` | `Array<{ body: string }>` | Discussion comments. |
+| `pattern` | `object` | Pattern object from `patterns()` with `category`, `count`, `refs` fields. |
 
-**Returns:** `number[]` — Unique referenced numbers.
+**Returns:** `string` — Multi-line string containing the marker, a description of what to update, refs, and suggested target file.
 
-### `classifyRefs(comments, refs)`
+The following example detects patterns, formats each as an objective, and passes it to the planner:
 
-Classify extracted references as blockers or informational using keyword heuristics (e.g., "blocked by #N", "depends on #N").
-
-**Parameters:**
-
-| Name | Type | Description |
-|------|------|-------------|
-| `comments` | `Array<{ body: string, author?: string }>` | Discussion comments containing the refs. |
-| `refs` | `number[]` | Extracted reference numbers from `extractRefs()`. |
+```js
+import { patterns, objective } from 'loreli/knowledge';
 
-**Returns:** `{ blockers: number[], references: number[] }`
+const found = await patterns(hub, repo, { threshold: 5 });
+for (const pattern of found) {
+  const text = objective(pattern);
+  await planner.plan(repo, text, { feedbackCategory: pattern.category });
+}
+```
 
 ## Feedback Marker Format
 
@@ -182,13 +171,6 @@ The `loreli:feedback` marker is an HTML comment embedded in PR or discussion com
 | `provider` | LLM provider that generated the feedback (e.g., `openai`, `anthropic`). |
 | `source` | Feedback origin: `pr` (PR review) or `plan` (plan verdict). |
 
-## Human Approval Workflow
-
-1. **Detection** — The `knowledge` reactor in `start.js` calls `patterns()` each tick. When a category crosses the threshold, `propose()` creates a promotion discussion.
-2. **Review** — Repo maintainers receive a GitHub notification. The discussion shows the recurring pattern with PR/discussion references, cross-provider consensus, and a suggested promotion target.
-3. **Decision** — The human checks one of: `[x] Approve` or `[x] Reject`, then **closes the discussion**.
-4. **Execution** — The `promotion-apply` reactor detects the closed, approved discussion and calls `apply()`, which creates an action issue targeting the selected file. An action agent picks up the issue and implements the change.
-
 ## Configuration
 
 ```yaml
@@ -207,31 +189,29 @@ feedback:
 
 ### How each setting affects the system
 
-**`enabled`** — Master switch. When `false`, no `loreli:feedback` markers are posted during PR reviews (`forward()` in `loreli/review` checks this before calling `classify()`). Plan verdict classification in `plan/verdict` does not check this flag because the MCP tool context lacks config access. Pattern detection and promotion reactors also check this flag before running.
-
-**`threshold`** — The minimum number of `loreli:feedback` markers in a single category before `patterns()` reports it as a recurring pattern. A pattern with 4 occurrences in a system configured with `threshold: 5` is invisible to the promotion pipeline. Cross-provider consensus (multiple LLM providers flagging the same category) lowers the effective threshold by 1, so a cross-provider pattern needs only 4 occurrences at the default threshold.
-
-**`categories`** — The list of categories that `classify()` is allowed to score against during PR review feedback capture. This acts as a **gate at the capture stage**: removing a category from this list means PR review feedback matching that category will never produce a `loreli:feedback` marker, which transitively means `patterns()` will never detect patterns in that category from PRs, and `propose()` will never create a promotion discussion for it.
+**`enabled`** — Master switch. When `false`, no `loreli:feedback` markers are posted during PR reviews (`forward()` in `loreli/review` checks this before calling `classify()`). Pattern detection reactors also check this flag before running.
 
-The six built-in categories and what they detect:
+**`threshold`** — The minimum number of `loreli:feedback` markers in a single category before `patterns()` reports it as a recurring pattern. Cross-provider consensus (multiple LLM providers flagging the same category) lowers the effective threshold by 1.
 
-| Category | Keywords | What it captures |
-|----------|----------|------------------|
-| `naming` | name, rename, prefix, convention, camelCase | Naming convention violations and style inconsistencies |
-| `architecture` | architect, structure, module, package, refactor, decouple | Structural concerns, module boundaries, coupling issues |
-| `testing` | test, coverage, assert, fixture, TDD, mock | Missing tests, inadequate coverage, testing methodology |
-| `documentation` | docs, document, README, JSDoc, comment, explain | Missing or incomplete documentation |
-| `performance` | perform, optimize, slow, memory, N+1, cache | Performance issues, optimization opportunities |
-| `security` | secure, secret, token, auth, vulnerable, inject | Security vulnerabilities, credential exposure, auth issues |
+**`categories`** — The six categories that `classify()` can return. These are defined in the `feedback.md` prompt template in `loreli/classify`:
 
-Categories cannot be extended via config — the keyword patterns are hardcoded in `KEYWORDS`. To add a new category, add an entry to `KEYWORDS` in `packages/knowledge/src/index.js` and include it in the `feedback.categories` default in `packages/config/src/defaults.js`.
+| Category | What it captures |
+|----------|------------------|
+| `naming` | Naming convention violations and style inconsistencies |
+| `architecture` | Structural concerns, module boundaries, coupling issues |
+| `testing` | Missing tests, inadequate coverage, testing methodology |
+| `documentation` | Missing or incomplete documentation |
+| `performance` | Performance issues, optimization opportunities |
+| `security` | Security vulnerabilities, credential exposure, auth issues |
 
-Plan verdict classification (`plan/verdict` in `packages/mcp/src/tools/github.js`) uses all hardcoded categories regardless of the config list, because the MCP tool context does not have access to the orchestrator config. This means plan feedback is always classified against all six categories even if the config restricts PR feedback to a subset.
+To modify categories, edit the `feedback.md` prompt template in `packages/classify/prompts/`.
 
 ## Errors
 
 | Error | Cause | Resolution |
 |-------|-------|------------|
+| `classify() requires a backends instance` | No `backends` option provided to `classify()` or `classifyRefs()`. | Pass a `BackendRegistry` instance from the orchestrator. |
+| LLM timeout / network error | The `oneshot()` call failed. | Check backend availability. Callers should wrap in `try/catch` and degrade gracefully. |
 | `category: not implemented` | Hub instance lacks the `category()` method. | Ensure the hub is a `GitHubHub` instance, not the base stub. |
 | `discussions: not implemented` | Hub instance lacks the `discussions()` method. | Same as above. |
 | Non-fatal catch blocks | Individual PR/discussion comment fetches may fail due to permissions or rate limits. | Patterns are still reported from successful fetches. Check GitHub token scopes if patterns seem incomplete. |

package/packages/knowledge/src/index.js

@@ -1,7 +1,7 @@
 /**
  * Knowledge capture engine — the write path.
  *
- * Classifies review feedback, detects recurring patterns across PRs,
+ * Classifies review feedback via LLM, detects recurring patterns across PRs,
  * proposes promotions via GitHub Discussions, and applies approved
  * promotions by creating issues.
  *
@@ -9,58 +9,31 @@
  */
 
 import { mark, parse } from 'loreli/marker';
+import { classify as llmClassify } from 'loreli/classify';
 import { logger } from 'loreli/log';
 import { createHash } from 'node:crypto';
 
 const log = logger('knowledge');
 
 /**
- * Keyword patterns for heuristic feedback classification.
- * Each entry maps a category to an array of regex patterns.
+ * Classify review feedback text into a category via LLM.
  *
- * @type {Record<string, RegExp[]>}
- */
-const KEYWORDS = {
-  naming: [/\bnam(e|ing)\b/i, /\brename\b/i, /\bprefix\b/i, /\bconvention\b/i, /\bcamelCase\b/i],
-  architecture: [/\barchitect/i, /\bstructur/i, /\bmodule\b/i, /\bpackage\b/i, /\brefactor/i, /\bdecouple/i],
-  testing: [/\btest/i, /\bcoverage\b/i, /\bassert/i, /\bfixture/i, /\bTDD\b/i, /\bmock\b/i],
-  documentation: [/\bdoc(s|ument)/i, /\bREADME\b/i, /\bJSDoc\b/i, /\bcomment/i, /\bexplain/i],
-  performance: [/\bperform/i, /\boptimiz/i, /\bslow\b/i, /\bmemory\b/i, /\bN\+1\b/i, /\bcache\b/i],
-  security: [/\bsecur/i, /\bsecret/i, /\btoken\b/i, /\bauth/i, /\bvulnerab/i, /\binject/i]
-};
-
-/**
- * Classify review feedback text into a category using keyword heuristics.
+ * Delegates to `loreli/classify` using the `feedback` prompt template.
+ * The prompt defines six categories: naming, architecture, testing,
+ * documentation, performance, security.
  *
  * @param {string} feedback - Review comment text.
  * @param {object} [opts] - Options.
- * @param {string[]} [opts.categories] - Allowed categories (defaults to all).
- * @returns {{category: string, confidence: number}}
+ * @param {object} opts.backends - BackendRegistry instance. Required.
+ * @param {object} [opts.config] - Config instance for model/timeout resolution.
+ * @returns {Promise<{category: string, confidence: number}>}
  */
-export function classify(feedback, opts = {}) {
-  const allowed = opts.categories ?? Object.keys(KEYWORDS);
-  const scores = {};
-
-  for (const cat of allowed) {
-    const patterns = KEYWORDS[cat];
-    if (!patterns) continue;
-    scores[cat] = 0;
-    for (const re of patterns) {
-      if (re.test(feedback)) scores[cat]++;
-    }
-  }
-
-  let best = 'documentation';
-  let max = 0;
-  for (const [cat, score] of Object.entries(scores)) {
-    if (score > max) {
-      max = score;
-      best = cat;
-    }
-  }
-
-  const confidence = max > 0 ? Math.min(max / 3, 1) : 0;
-  return { category: best, confidence };
+export async function classify(feedback, opts = {}) {
+  const result = await llmClassify('feedback', feedback, {
+    backends: opts.backends,
+    config: opts.config
+  });
+  return { category: result.category, confidence: result.confidence ?? 0.8 };
 }
 
 /**
@@ -152,7 +125,7 @@ export async function patterns(hub, repo, opts = {}) {
       summary: `${category} feedback pattern (${bucket.items.length} occurrences)`,
       category,
       count: bucket.items.length,
-      fingerprint: fingerprint(`${category}:${bucket.items.length}`),
+      fingerprint: fingerprint(category),
       providers: bucket.providers,
       refs: bucket.items
     });
@@ -176,186 +149,52 @@ function target(refs) {
 }
 
 /**
- * Map of target keys to their display labels.
+ * Map of target keys to file paths for objective() output.
  *
  * @type {Record<string, string>}
  */
-const TARGETS = {
-  agents: 'AGENTS.md -- universal coding convention',
-  planner: 'Planner prompt -- planning standards (.loreli/planner.md)',
-  reviewer: 'Reviewer prompt -- review criteria (.loreli/review.md)',
-  action: 'Action prompt -- implementation guidance (.loreli/action.md)',
-  risk: 'Risk prompt -- risk assessment criteria (.loreli/risk.md)'
+const OBJECTIVE_FILES = {
+  agents: 'AGENTS.md',
+  planner: '.loreli/planner.md',
+  reviewer: '.loreli/review.md',
+  action: '.loreli/action.md',
+  risk: '.loreli/risk.md'
 };
 
 /**
- * Create a promotion discussion for a detected pattern.
+ * Format a detected feedback pattern into a planning objective string.
  *
- * The template includes a smart target suggestion pre-checked based on
- * feedback source distribution, mixed PR/discussion ref formatting, and
- * clear human instructions for the decision workflow.
+ * Embeds a `loreli:feedback` marker so downstream tools can auto-detect
+ * the feedback category and apply appropriate labels.
  *
- * @param {object} hub - Hub instance.
- * @param {string} repo - "owner/name" repository.
  * @param {object} pattern - Pattern from patterns().
- * @returns {Promise<{number: number, id: string, url: string}>}
+ * @returns {string} Planning objective text.
  */
-export async function propose(hub, repo, pattern) {
-  const fp = pattern.fingerprint;
-  const providerLine = Object.entries(pattern.providers)
-    .map(function fmt([p, n]) { return `${p} (${n})`; })
-    .join(', ');
-
+export function objective(pattern) {
+  const suggested = target(pattern.refs);
+  const file = OBJECTIVE_FILES[suggested] ?? 'AGENTS.md';
   const refs = pattern.refs
+    .slice(0, 10)
     .map(function fmt(r) {
       const prefix = r.type === 'discussion' ? 'Discussion' : 'PR';
       return `- ${prefix} #${r.ref}: "${r.excerpt}"`;
     })
     .join('\n');
 
-  const suggested = target(pattern.refs);
-  const targetCheckboxes = Object.entries(TARGETS)
-    .map(function fmt([key, label]) {
-      const checked = key === suggested ? 'x' : ' ';
-      return `- [${checked}] ${label}`;
-    })
-    .join('\n');
-
-  const body = [
-    mark('promotion', { fingerprint: fp, category: pattern.category, status: 'pending' }),
+  return [
+    mark('feedback', { category: pattern.category }),
     '',
-    '## Pattern',
+    `Update \`${file}\` to enforce a new standard for "${pattern.category}"`,
+    'based on recurring review feedback.',
     '',
-    `This review feedback appeared in ${pattern.count} reviews:`,
+    `This pattern appeared ${pattern.count} times:`,
     refs,
     '',
-    `**Category**: ${pattern.category}`,
-    `**Providers**: ${providerLine}`,
-    '',
-    '## Proposed Promotion',
-    '',
-    'Select the promotion target (suggested target is pre-selected based on feedback source):',
-    '',
-    targetCheckboxes,
-    '',
-    '> _Describe the rule or convention to promote here._',
-    '',
-    '## Decision',
-    '',
-    'Check **one** option below, then **close this discussion** to trigger the promotion pipeline.',
-    '',
-    '- [ ] Approve -- apply this as a standard',
-    '- [ ] Reject -- this is a preference, not a standard',
-    '',
-    '> Closing without checking a box takes no action. The discussion can be reopened to reconsider.'
+    `Category: ${pattern.category}`,
+    `Suggested target: ${file}`
   ].join('\n');
-
-  const cat = await hub.category(repo, 'Loreli');
-  const disc = await hub.discuss(repo, {
-    title: `Promotion: ${pattern.summary}`,
-    body,
-    categoryId: cat.id,
-    repositoryId: cat.repositoryId
-  });
-
-  log.info(`propose: created promotion discussion #${disc.number} for ${pattern.category}`);
-  return disc;
 }
 
-/**
- * Map of target checkbox labels to concrete file paths.
- *
- * @type {Record<string, string>}
- */
-const TARGET_FILES = {
-  'AGENTS.md': 'AGENTS.md',
-  'Planner prompt': '.loreli/planner.md',
-  'Reviewer prompt': '.loreli/review.md',
-  'Action prompt': '.loreli/action.md',
-  'Risk prompt': '.loreli/risk.md'
-};
-
-/**
- * Parse the selected target from a promotion discussion body by finding
- * the first checked checkbox (`- [x]`) that matches a known target label.
- *
- * @param {string} body - Promotion discussion body.
- * @returns {{label: string, file: string}}
- */
-function extractTarget(body) {
-  const checked = /- \[x\] (\w[\w\s]*?)(?:\s+--|\s*$)/gm;
-  let m;
-  while ((m = checked.exec(body)) !== null) {
-    const label = m[1].trim();
-    if (TARGET_FILES[label]) return { label, file: TARGET_FILES[label] };
-  }
-  return { label: 'AGENTS.md', file: 'AGENTS.md' };
-}
-
-/**
- * Execute an approved promotion by creating an action issue.
- *
- * Parses the selected promotion target from the discussion body and
- * includes the concrete file path in the action issue so the
- * implementing agent knows exactly which file to update.
- *
- * @param {object} hub - Hub instance.
- * @param {string} repo - "owner/name" repository.
- * @param {object} promotion - Promotion data.
- * @param {string} promotion.summary - Pattern summary.
- * @param {number} promotion.discussion - Discussion number.
- * @param {string} promotion.body - Full promotion discussion body.
- * @returns {Promise<{number: number, url: string}>}
- */
-export async function apply(hub, repo, promotion) {
-  const { label, file } = extractTarget(promotion.body);
-
-  const body = [
-    `Apply the approved promotion from discussion #${promotion.discussion}.`,
-    '',
-    '## Target',
-    '',
-    `**Target file**: \`${file}\``,
-    `**Selected by**: ${label}`,
-    '',
-    '## Change',
-    '',
-    promotion.body,
-    '',
-    '## Reference',
-    '',
-    `Promotion discussion: #${promotion.discussion}`
-  ].join('\n');
-
-  const issue = await hub.open(repo, {
-    title: `Apply promotion: ${promotion.summary}`,
-    body,
-    labels: ['loreli', 'loreli:action']
-  });
-
-  log.info(`apply: created action issue #${issue.number} for promotion from #${promotion.discussion}`);
-  return issue;
-}
-
-/**
- * Blocker signal patterns (case-insensitive). #REF is replaced with the
- * actual #N reference when testing. A ref matches as a blocker if any
- * pattern matches the joined comment text.
- *
- * @type {RegExp[]}
- */
-const BLOCKER_SIGNALS = [
-  /\bneed(?:s|ed)?\b.*#REF\b/i,
-  /\bblock(?:s|ed|ing)?\s+(?:by\s+)?#REF\b/i,
-  /\bdepend(?:s|ing)?\s+on\s+#REF\b/i,
-  /\bwait(?:s|ing)?\s+(?:for|on)\s+#REF\b/i,
-  /\brequir(?:es?|ing)\b.*#REF\b/i,
-  /\bprerequisite\b.*#REF\b/i,
-  /\bafter\s+#REF\s+(?:is\s+)?(?:resolved|merged|closed)/i,
-  /\bbefore\s+(?:we|this)\s+can\b.*#REF\b/i,
-  /\bcan(?:no|')?t\s+(?:proceed|start|continue)\b.*#REF\b/i
-];
-
 /**
  * Extract unique issue/PR number references from discussion comments.
  * Matches `#N` patterns in comment bodies.
@@ -372,41 +211,33 @@ export function extractRefs(comments) {
 }
 
 /**
- * Classify issue/PR references as blockers or informational using keyword
- * heuristics. For each ref, scans the comment text around that ref for
- * blocker signal patterns. Returns structured classification so the caller
- * can verify blockers against the hub before parking a discussion.
+ * Classify issue/PR references as blockers or informational via LLM.
+ *
+ * Delegates to `loreli/classify` using the `blocker` prompt template,
+ * which returns per-ref classification: `{blockers: [...], references: [...]}`.
  *
  * @param {Array<{body: string, author?: string}>} comments - Discussion comments containing the refs.
  * @param {number[]} refs - Extracted reference numbers.
- * @returns {{blockers: number[], references: number[]}}
+ * @param {object} [opts] - Options.
+ * @param {object} opts.backends - BackendRegistry instance. Required.
+ * @param {object} [opts.config] - Config instance.
+ * @returns {Promise<{blockers: number[], references: number[]}>}
  */
-export function classifyRefs(comments, refs) {
+export async function classifyRefs(comments, refs, opts = {}) {
   if (!refs.length) return { blockers: [], references: [] };
 
   const text = comments.map(function format(c) {
     return c.author ? `${c.author}: ${c.body}` : c.body;
   }).join('\n');
 
-  const blockers = [];
-  const references = [];
-
-  for (const ref of refs) {
-    const refStr = '#' + ref;
-    let isBlocker = false;
-
-    for (const pattern of BLOCKER_SIGNALS) {
-      const source = pattern.source.replace(/#REF\b/g, refStr);
-      const re = new RegExp(source, pattern.flags);
-      if (re.test(text)) {
-        isBlocker = true;
-        break;
-      }
-    }
-
-    if (isBlocker) blockers.push(ref);
-    else references.push(ref);
-  }
+  const result = await llmClassify('blocker', text, {
+    backends: opts.backends,
+    config: opts.config,
+    vars: { refs: refs.map(function fmt(r) { return '#' + r; }).join(', ') }
+  });
 
-  return { blockers, references };
+  return {
+    blockers: result.blockers ?? [],
+    references: result.references ?? []
+  };
 }