loreli 1.0.0 → 2.0.0

package/packages/planner/src/index.js

@@ -8,6 +8,12 @@ import { logger } from 'loreli/log';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const log = logger('planner');
+/**
+ * Default objective label used when no scoped objective metadata is available.
+ *
+ * @type {string}
+ */
+const FALLBACK_OBJECTIVE = 'Planning objective';
 
 /**
  * Path to the plan-reviewer prompt template. Used for rendering the
@@ -25,6 +31,20 @@ const PLAN_REVIEWER_TEMPLATE = join(__dirname, '..', 'prompts', 'plan-reviewer.m
  */
 const TIEBREAKER_TEMPLATE = join(__dirname, '..', 'prompts', 'tiebreaker-reviewer.md');
 
+/**
+ * Maximum time a dispatched planner can run without creating any
+ * planning discussion before it is considered stalled.
+ *
+ * The planning bootstrap path has a strict E2E timeout. A planner
+ * process that stays "working" without producing its first discussion
+ * can block scaling indefinitely because demand() sees non-zero supply.
+ * This timeout lets recover()/demand() treat that planner as stale so
+ * a replacement can be spawned before bootstrap times out.
+ *
+ * @type {number}
+ */
+const PENDING_PLANNER_TIMEOUT = 120000;
+
 /**
  * Planning workflow for Loreli's orchestration pipeline.
  *
@@ -161,6 +181,14 @@ export class PlannerWorkflow extends Workflow {
    */
   _dispatched = new Set();
 
+  /**
+   * Timestamp (ms) when each planner last received the objective prompt.
+   * Used to detect stale bootstrap attempts that never created discussions.
+   *
+   * @type {Map<string, number>}
+   */
+  _dispatchedAt = new Map();
+
   /**
    * Report planner demand: how many open discussions need a planner
    * agent. Planner demand is typically low — one planner handles the
@@ -178,11 +206,29 @@ export class PlannerWorkflow extends Workflow {
     // Objective dispatched but planner died before creating any
     // discussion → treat as pending workload so scale() spawns
     // a replacement planner.
-    const pending = this.objective && all.length === 0;
+    const pending = Boolean(this.objective) && all.length === 0;
     const workload = open.length > 0 || pending ? 1 : 0;
-    const supply = this.agents().filter(function active(a) {
-      return a.state !== 'dormant';
-    }).length;
+    const now = Date.now();
+    let supply = 0;
+
+    for (const agent of this.agents()) {
+      if (agent.state === 'dormant') continue;
+      const name = agent.identity?.name;
+      if (!pending || !name || !this._dispatched.has(name)) {
+        supply++;
+        continue;
+      }
+
+      const sentAt = this._dispatchedAt.get(name);
+      if (typeof sentAt !== 'number' || now - sentAt < PENDING_PLANNER_TIMEOUT) {
+        supply++;
+        continue;
+      }
+
+      log.warn(
+        `demand: stale planner bootstrap ${name} (${Math.round((now - sentAt) / 1000)}s without discussions)`
+      );
+    }
 
     return { workload, supply, deficit: Math.max(0, workload - supply) };
   }
@@ -231,7 +277,19 @@ export class PlannerWorkflow extends Workflow {
    * @returns {Promise<void>}
    */
   async hydrate(repo) {
-    if (!this.hub || !this.categoryId) return;
+    if (!this.hub) return;
+
+    if (!this.categoryId) {
+      try {
+        const cat = await this.hub.category(repo, 'Loreli');
+        this.categoryId = cat.id;
+        this.repositoryId = cat.repositoryId;
+        log.info('hydrate: lazily resolved Loreli category');
+      } catch (err) {
+        log.debug(`hydrate: category resolution failed: ${err.message}`);
+        return;
+      }
+    }
 
     const all = await this.hub.discussions(repo, this.categoryId);
 
@@ -293,6 +351,66 @@ export class PlannerWorkflow extends Workflow {
     }
   }
 
+  /**
+   * Archive orphaned open planning discussions before a new objective run.
+   *
+   * A prior interrupted session can leave planner-created discussions open
+   * without any review state. New callers that poll for "any open discussion"
+   * can accidentally latch these stale drafts instead of the fresh objective.
+   * To keep the planning pipeline deterministic, archive only discussions that
+   * look orphaned: open, planner-authored, no terminal review labels, and no
+   * comments.
+   *
+   * @param {string} repo - Repository in "owner/name" format.
+   * @returns {Promise<number>} Number of discussions archived.
+   */
+  async archive(repo) {
+    if (!this.categoryId) return 0;
+    if (typeof this.hub?.discussions !== 'function') return 0;
+    if (typeof this.hub?.discussion !== 'function') return 0;
+    if (typeof this.hub?.closeDiscussion !== 'function') return 0;
+
+    const all = await this.hub.discussions(repo, this.categoryId);
+    const stale = all.filter(function orphaned(d) {
+      return !d.closed &&
+        d.labels.includes('loreli:planner') &&
+        !d.labels.includes('loreli:approved') &&
+        !d.labels.includes('loreli:changes-requested') &&
+        !d.labels.includes('loreli:blocked') &&
+        !d.labels.includes('loreli:needs-attention');
+    });
+
+    let archived = 0;
+    for (const disc of stale) {
+      let full;
+      try {
+        full = await this.hub.discussion(repo, disc.number);
+      } catch (err) {
+        log.debug(`archive: skipping #${disc.number} — read failed: ${err.message}`);
+        continue;
+      }
+      if ((full.comments?.length ?? 0) > 0) continue;
+
+      if (typeof this.hub.applyDiscussionLabels === 'function') {
+        try {
+          await this.hub.applyDiscussionLabels(repo, disc.id, ['loreli:abandoned']);
+        } catch (err) {
+          log.warn(`archive: failed to label #${disc.number} as abandoned: ${err.message}`);
+        }
+      }
+
+      try {
+        await this.hub.closeDiscussion(disc.id);
+        archived++;
+        log.info(`archive: closed stale discussion #${disc.number} before planning`);
+      } catch (err) {
+        log.warn(`archive: failed to close stale discussion #${disc.number}: ${err.message}`);
+      }
+    }
+
+    return archived;
+  }
+
   /**
    * Dispatch the planning workflow to planner agents.
    *
@@ -302,20 +420,25 @@ export class PlannerWorkflow extends Workflow {
    *
    * @param {string} repo - Repository in "owner/name" format.
    * @param {string} objective - What should be planned.
+   * @param {object} [opts] - Options.
+   * @param {string} [opts.feedbackCategory] - Feedback category that triggered this plan.
    * @returns {Promise<{planners: string[], categoryId: string}>}
    * @throws {Error} When no planner agents are available.
    */
-  async plan(repo, objective) {
+  async plan(repo, objective, opts = {}) {
     log.info(`planning: ${repo} — objective: ${objective}`);
     const planners = this.agents();
 
     if (!planners.length) throw new Error('No planner agents available');
 
     this.objective = objective;
+    this._dispatched.clear();
+    this._dispatchedAt.clear();
 
     const cat = await this.hub.category(repo, 'Loreli');
     this.categoryId = cat.id;
     this.repositoryId = cat.repositoryId;
+    await this.archive(repo);
     const dispatched = [];
 
     for (const agent of planners) {
@@ -327,6 +450,7 @@ export class PlannerWorkflow extends Workflow {
         model: agent.identity.model,
         objective,
         labels: agent.identity.labels?.('planner'),
+        feedbackCategory: opts.feedbackCategory ?? null,
         plan: true,
         categoryId: cat.id,
         repositoryId: cat.repositoryId
@@ -334,6 +458,7 @@ export class PlannerWorkflow extends Workflow {
 
       this.orchestrator.activity(agent.identity.name);
       this._dispatched.add(agent.identity.name);
+      this._dispatchedAt.set(agent.identity.name, Date.now());
       dispatched.push(agent.identity.name);
     }
 
@@ -363,11 +488,38 @@ export class PlannerWorkflow extends Workflow {
     const all = await this.hub.discussions(repo, this.categoryId);
     if (all.length > 0) return;
 
+    const now = Date.now();
+    const retired = new Set();
     const planners = this.agents().filter(function eligible(a) {
       return a.state !== 'dormant';
     });
 
     for (const agent of planners) {
+      const name = agent.identity.name;
+      if (!this._dispatched.has(name)) continue;
+
+      const sentAt = this._dispatchedAt.get(name);
+      if (typeof sentAt !== 'number') continue;
+
+      const elapsed = now - sentAt;
+      if (elapsed < PENDING_PLANNER_TIMEOUT) continue;
+
+      if (typeof this.orchestrator?.kill === 'function') {
+        try {
+          await this.orchestrator.kill(name);
+          log.warn(`recover: killed stale planner ${name} after ${Math.round(elapsed / 1000)}s without discussions`);
+        } catch (err) {
+          log.warn(`recover: failed to kill stale planner ${name}: ${err.message}`);
+        }
+      }
+
+      retired.add(name);
+      this._dispatched.delete(name);
+      this._dispatchedAt.delete(name);
+    }
+
+    for (const agent of planners) {
+      if (retired.has(agent.identity.name)) continue;
       if (this._dispatched.has(agent.identity.name)) continue;
 
       log.info(`recover: re-dispatching objective to ${agent.identity.name}`);
@@ -386,6 +538,7 @@ export class PlannerWorkflow extends Workflow {
 
       this.orchestrator.activity(agent.identity.name);
       this._dispatched.add(agent.identity.name);
+      this._dispatchedAt.set(agent.identity.name, Date.now());
     }
   }
 
@@ -495,12 +648,19 @@ export class PlannerWorkflow extends Workflow {
     for (const disc of needsRevision) {
       const full = await this.hub.discussion(repo, disc.number);
 
-      // ── Blocker detection via heuristic classification ──
       const refs = extractRefs(full.comments);
       if (refs.length) {
-        const classified = classifyRefs(full.comments, refs);
+        let classified;
+        try {
+          classified = await classifyRefs(full.comments, refs, {
+            backends: this.orchestrator.backendRegistry,
+            config: this.orchestrator.cfg
+          });
+        } catch (err) {
+          log.debug(`revise: blocker classification unavailable for #${disc.number}, skipping: ${err.message}`);
+        }
 
-        if (classified.blockers.length) {
+        if (classified?.blockers?.length) {
           // Verify classified blockers are actually open issues
           const open = [];
           for (const ref of classified.blockers) {
@@ -617,13 +777,13 @@ export class PlannerWorkflow extends Workflow {
     if (!this.categoryId) return { reviewer: null, discussions: 0 };
 
     // Clear stale in-flight entries when no productive reviewer exists.
-    // An active reviewer must be in a working state (spawned/running) —
+    // An active reviewer must be in a working state (spawned/working) —
     // dormant agents finished their work, dead agents crashed, and
     // stalled agents may never produce output.
     const reviewers = [...this.orchestrator.agents.values()]
       .filter(function isReviewer(a) { return a.role === 'reviewer'; });
-    const productive = reviewers.filter(function working(a) {
-      return a.state === 'spawned' || a.state === 'running';
+    const productive = reviewers.filter(function active(a) {
+      return a.state === 'spawned' || a.state === 'working';
     });
 
     if (!productive.length && this._inflight.size) {
@@ -661,7 +821,7 @@ export class PlannerWorkflow extends Workflow {
         const assignee = this._reviewerName
           ? this.orchestrator.agents.get(this._reviewerName)
           : null;
-        const alive = assignee && (assignee.state === 'spawned' || assignee.state === 'running' || assignee.state === 'working');
+        const alive = assignee && (assignee.state === 'spawned' || assignee.state === 'working');
         if (alive) {
           log.debug(`review: reviewer ${this._reviewerName} still working on #${this._reviewing} — waiting`);
           return { reviewer: null, discussions: 0 };
@@ -817,6 +977,8 @@ export class PlannerWorkflow extends Workflow {
    * Runs LAST in the tick pipeline. For each discussion with the
    * `loreli:approved` label, creates a real issue, posts a closing
    * comment linking to the issue, and closes/locks the discussion.
+   * Promoted issues are stamped with a `loreli:plan` marker that carries
+   * the planning objective so parent-child linking can scope correctly.
    *
    * @param {string} repo - Repository in "owner/name" format.
    * @returns {Promise<Array<{number: number, title: string}>>}
@@ -852,11 +1014,19 @@ export class PlannerWorkflow extends Workflow {
 
     for (const disc of approved) {
       try {
-        // Strip the discussion's existing signature so open() applies
-        // exactly one fresh stamp — prevents double-signature on promoted issues.
+        const objective = this.objective ?? FALLBACK_OBJECTIVE;
+        const carry = disc.labels.filter(function passthrough(l) {
+          return l === 'loreli:refactor' || l.startsWith('loreli:feedback:');
+        });
+        const body = [
+          Identity.strip(disc.body),
+          mark('plan', { objective, discussion: String(disc.number) })
+        ].join('\n\n');
+
         const issue = await scoped.open(repo, {
           title: disc.title,
-          body: Identity.strip(disc.body)
+          body,
+          ...(carry.length && { labels: carry })
         });
 
         // Post themed closing comment linking to the new issue.
@@ -894,6 +1064,8 @@ export class PlannerWorkflow extends Workflow {
       this._reviewerName = null;
       this._inflight.clear();
       this._revising.clear();
+      this._dispatched.clear();
+      this._dispatchedAt.clear();
 
       const planners = this.agents();
       for (const p of planners) {
@@ -931,11 +1103,11 @@ export class PlannerWorkflow extends Workflow {
    * is fully idempotent and distributed-safe across multiple machines.
    *
    * Flow:
-   * 1. Scan for existing parent issue (loreli:parent label + marker)
-   * 2. Deduplicate racing parents (keep lowest issue number)
-   * 3. Discover unlinked child issues (loreli-labeled, agent-stamped, not parent)
-   * 4. Create parent if >= 2 children and no parent exists
-   * 5. Link unlinked children via sub-issues API
+   * 1. Scan for existing parent issues (label + marker) and scope by objective
+   * 2. Deduplicate racing parents per objective (keep lowest issue number)
+   * 3. Discover child issues and resolve objective from `loreli:plan` marker
+   * 4. Create a parent for objective groups with >= 2 children and no parent
+   * 5. Link unlinked children to the objective's canonical parent
    *
    * @param {string} repo - Repository in "owner/name" format.
    * @returns {Promise<void>}
@@ -949,118 +1121,161 @@ export class PlannerWorkflow extends Workflow {
       return;
     }
 
-    // Find existing parent issues via label scan
-    const candidates = await this.hub.issues(repo, {
+    // Find existing parent issues via label scan. If the label index is
+    // stale, fall back to an unfiltered scan and filter labels locally.
+    let candidates = await this.hub.issues(repo, {
       state: 'open', labels: ['loreli:parent']
     });
+    if (!candidates.length) {
+      const open = await this.hub.issues(repo, { state: 'open' });
+      candidates = open.filter(function withParentLabel(issue) {
+        return issue.labels.includes('loreli:parent');
+      });
+    }
 
     // Confirm via marker — guards against accidental manual labeling
-    const parents = candidates.filter(function confirmed(i) {
-      return has(i.body, 'parent');
+    const parents = candidates.filter(function confirmed(issue) {
+      return has(issue.body, 'parent');
+    }).map(function withObjective(issue) {
+      const objective = parse(issue.body, 'parent')?.objective ?? FALLBACK_OBJECTIVE;
+      return { issue, objective };
     });
-
-    let parent = null;
-
-    // Deduplicate racing parents: keep lowest number, close others
-    if (parents.length > 1) {
-      parents.sort(function byNumber(a, b) { return a.number - b.number; });
-      parent = parents[0];
-
-      for (let i = 1; i < parents.length; i++) {
-        try {
-          const signer = this.agents()[0]?.identity ?? this.orchestrator?.clientIdentity;
-          if (signer) {
-            const scoped = this.hub.as(signer, 'planner');
-            await scoped.comment(repo, parents[i].number,
-              `Duplicate parent detected. Keeping #${parent.number} as canonical parent.`);
-          }
-          // Close via direct Octokit — hub doesn't expose issue update yet
-          const [owner, name] = this.hub.parse(repo);
-          await this.hub.client.issues.update({
-            owner, repo: name, issue_number: parents[i].number, state: 'closed'
-          });
-          log.info(`link: closed duplicate parent #${parents[i].number} — keeping #${parent.number}`);
-        } catch (err) {
-          log.warn(`link: failed to close duplicate parent #${parents[i].number}: ${err.message}`);
-        }
-      }
-    } else if (parents.length === 1) {
-      parent = parents[0];
-    }
+    const parentObjectives = [...new Set(parents.map(function objective(entry) {
+      return entry.objective;
+    }))];
+    const parentHint = parentObjectives.length === 1 ? parentObjectives[0] : null;
 
     // Discover child issues: agent-stamped loreli issues that are NOT the parent.
     // The agent marker guards against human-created issues being linked as
     // sub-issues — only issues promoted from plans carry the stamp.
-    const all = await this.hub.issues(repo, { state: 'open', labels: ['loreli'] });
-    const children = all.filter(function isChild(i) {
-      return has(i.body, 'agent') && !has(i.body, 'parent') && i.number !== parent?.number;
+    let all = await this.hub.issues(repo, { state: 'open', labels: ['loreli'] });
+    if (!all.length) {
+      const open = await this.hub.issues(repo, { state: 'open' });
+      all = open.filter(function withLoreliLabel(issue) {
+        return issue.labels.includes('loreli');
+      });
+    }
+
+    const activeObjective = this.objective;
+    const children = all.filter(function isChild(issue) {
+      return has(issue.body, 'agent') && !has(issue.body, 'parent');
+    }).map(function withObjective(issue) {
+      const derived = parse(issue.body, 'plan')?.objective ?? activeObjective ?? parentHint ?? FALLBACK_OBJECTIVE;
+      return { issue, objective: derived };
     });
 
-    if (children.length < 2 && !parent) {
-      // Not enough children for a parent hierarchy yet
-      if (children.length > 0) {
-        log.debug(`link: ${children.length} child issue(s) — waiting for more before creating parent`);
+    const objectives = new Set();
+    for (const entry of parents) objectives.add(entry.objective);
+    for (const entry of children) objectives.add(entry.objective);
+
+    for (const objective of objectives) {
+      const scopedParents = parents
+        .filter(function inScope(entry) { return entry.objective === objective; })
+        .map(function issue(entry) { return entry.issue; });
+      const scopedChildren = children
+        .filter(function inScope(entry) { return entry.objective === objective; })
+        .map(function issue(entry) { return entry.issue; });
+
+      let parent = null;
+
+      // Deduplicate racing parents per objective: keep lowest number, close others.
+      if (scopedParents.length > 1) {
+        scopedParents.sort(function byNumber(a, b) { return a.number - b.number; });
+        parent = scopedParents[0];
+
+        for (let i = 1; i < scopedParents.length; i++) {
+          try {
+            const signer = this.agents()[0]?.identity ?? this.orchestrator?.clientIdentity;
+            if (signer) {
+              const scoped = this.hub.as(signer, 'planner');
+              await scoped.comment(repo, scopedParents[i].number,
+                `Duplicate parent detected. Keeping #${parent.number} as canonical parent.`);
+            }
+            // Close via direct Octokit — hub doesn't expose issue update yet
+            const [owner, name] = this.hub.parse(repo);
+            await this.hub.client.issues.update({
+              owner, repo: name, issue_number: scopedParents[i].number, state: 'closed'
+            });
+            log.info(
+              `link: closed duplicate parent #${scopedParents[i].number} ` +
+              `for objective "${objective}" — keeping #${parent.number}`
+            );
+          } catch (err) {
+            log.warn(`link: failed to close duplicate parent #${scopedParents[i].number}: ${err.message}`);
+          }
+        }
+      } else if (scopedParents.length === 1) {
+        parent = scopedParents[0];
       }
-      return;
-    }
 
-    // Create parent if needed
-    if (!parent && children.length >= 2) {
-      const signer = this.agents()[0]?.identity ?? this.orchestrator?.clientIdentity;
-      if (!signer) {
-        log.warn('link: no identity available for creating parent issue');
-        return;
+      if (scopedChildren.length < 2 && !parent) {
+        // Not enough children for a parent hierarchy yet
+        if (scopedChildren.length > 0) {
+          log.debug(
+            `link: ${scopedChildren.length} child issue(s) for objective "${objective}" ` +
+            '— waiting for more before creating parent'
+          );
+        }
+        continue;
       }
 
-      const objective = this.objective ?? 'Planning objective';
-      const title = objective.split('\n')[0].slice(0, 128);
-      const taskList = children
-        .map(function line(c) { return `- [ ] #${c.number} — ${c.title}`; })
-        .join('\n');
+      // Create parent if needed
+      if (!parent && scopedChildren.length >= 2) {
+        const signer = this.agents()[0]?.identity ?? this.orchestrator?.clientIdentity;
+        if (!signer) {
+          log.warn('link: no identity available for creating parent issue');
+          return;
+        }
 
-      const body = [
-        '## Objective\n',
-        objective,
-        '\n### Work Items\n',
-        taskList,
-        '\n',
-        mark('parent', { objective })
-      ].join('\n');
-
-      const scoped = this.hub.as(signer, 'planner');
-      const created = await scoped.open(repo, {
-        title,
-        body,
-        labels: ['loreli:parent']
-      });
+        const title = objective.split('\n')[0].slice(0, 128);
+        const taskList = scopedChildren
+          .map(function line(child) { return `- [ ] #${child.number} — ${child.title}`; })
+          .join('\n');
+
+        const body = [
+          '## Objective\n',
+          objective,
+          '\n### Work Items\n',
+          taskList,
+          '\n',
+          mark('parent', { objective })
+        ].join('\n');
+
+        const scoped = this.hub.as(signer, 'planner');
+        const created = await scoped.open(repo, {
+          title,
+          body,
+          labels: ['loreli:parent']
+        });
 
-      parent = created;
-      log.info(`link: created parent issue #${parent.number} for objective: ${objective}`);
-    }
+        parent = created;
+        log.info(`link: created parent issue #${parent.number} for objective: ${objective}`);
+      }
 
-    if (!parent) return;
+      if (!parent) continue;
 
-    // Get already-linked sub-issues for idempotency
-    let linked;
-    try {
-      linked = await this.hub.subs(repo, parent.number);
-    } catch {
-      // Sub-issues API may not be available — log and bail
-      log.warn('link: sub-issues API unavailable — skipping linking');
-      return;
-    }
+      // Get already-linked sub-issues for idempotency
+      let linked;
+      try {
+        linked = await this.hub.subs(repo, parent.number);
+      } catch {
+        // Sub-issues API may not be available — log and bail
+        log.warn('link: sub-issues API unavailable — skipping linking');
+        return;
+      }
 
-    const linkedIds = new Set(linked.map(function id(s) { return s.id; }));
+      const linkedIds = new Set(linked.map(function id(subIssue) { return subIssue.id; }));
 
-    // Link unlinked children
-    for (const child of children) {
-      if (linkedIds.has(child.id)) continue;
+      // Link unlinked children
+      for (const child of scopedChildren) {
+        if (linkedIds.has(child.id)) continue;
 
-      try {
-        await this.hub.sub(repo, parent.number, child.id);
-        log.info(`link: linked #${child.number} as sub-issue of #${parent.number}`);
-      } catch (err) {
-        log.warn(`link: failed to link #${child.number} to #${parent.number}: ${err.message}`);
+        try {
+          await this.hub.sub(repo, parent.number, child.id);
+          log.info(`link: linked #${child.number} as sub-issue of #${parent.number}`);
+        } catch (err) {
+          log.warn(`link: failed to link #${child.number} to #${parent.number}: ${err.message}`);
+        }
       }
     }
   }

package/packages/review/README.md

@@ -15,7 +15,7 @@ ReviewWorkflow's `scan()` uses a **label gate** to wait for risk assessment befo
 - **`loreli:medium-risk`** — Reviewer dispatched with risk context attached to the prompt.
 - **`loreli:critical-risk`** — PR added to `_completed` immediately; HITL escalation is handled by `loreli/risk`.
 
-Setting `review.skipRiskAssessment: true` in `loreli.yml` disables the label gate entirely.
+Setting `workflows.risk.skip: true` in `loreli.yml` disables the label gate entirely.
 
 ## API Reference
 
@@ -38,7 +38,7 @@ const review = new ReviewWorkflow(orchestrator, hub);
 
 #### `review.scan(repo)` → Promise\<Array\<{pr, reviewer}\>\>
 
-Scan for new PRs created by action agents and dispatch reviewers. Uses branch naming convention (`{agentName}/issue-{number}`) to match PRs to agents. Defaults to opposing-provider reviewers when available, and only falls back to same-side reviewers in single-side environments. Requires a risk label on the PR unless `skipRiskAssessment` is true.
+Scan for new PRs created by action agents and dispatch reviewers. Uses branch naming convention (`{agentName}/issue-{number}`) to match PRs to agents. Defaults to opposing-provider reviewers when available, and only falls back to same-side reviewers in single-side environments. Requires a risk label on the PR unless `workflows.risk.skip` is true.
 
 The `demand()` signal is topology-aware. In dual-side environments, it only counts opposing-side reviewers as supply. In single-side environments, same-side reviewers count as valid supply.