@neriros/ralphy 2.17.3 → 2.19.0

package/README.md

@@ -169,10 +169,13 @@ A default `ralphy.config.json` is written on first run with every defaulted sett
     "assignee": "me",
     "postComments": true,
     "updateEveryIterations": 10,
+    "mentionTrigger": true,
+    "mentionHandle": "@ralphy",
     "indicators": {
       "getTodo": { "filter": [{ "type": "status", "value": "Todo" }] },
       "getInProgress": { "filter": [{ "type": "status", "value": "In Progress" }] },
       "getConflicted": { "filter": [{ "type": "label", "value": "ralph:conflicted" }] },
+      "getReview": { "filter": [{ "type": "label", "value": "ralph:review" }] },
       "setInProgress": { "type": "status", "value": "In Progress" },
       "setDone": {
         "apply": [
@@ -183,6 +186,7 @@ A default `ralphy.config.json` is written on first run with every defaulted sett
       "setError": { "type": "label", "value": "ralph:error" },
       "setConflicted": { "type": "label", "value": "ralph:conflicted" },
       "clearConflicted": { "type": "label", "value": "ralph:conflicted" },
+      "clearReview": { "type": "label", "value": "ralph:review" },
     },
   },
   "useWorktree": true,
@@ -205,9 +209,13 @@ A default `ralphy.config.json` is written on first run with every defaulted sett
 
 Linear is the source of truth for which issues Ralph has touched. Each `linear.indicators` key names a lifecycle event:
 
-- `getTodo` / `getInProgress` / `getConflicted` — `{ filter: [...] }` selectors used to find issues to pick up, resume, or repair.
+- `getTodo` / `getInProgress` / `getConflicted` / `getReview` — `{ filter: [...] }` selectors used to find issues to pick up, resume, repair, or follow up on after review.
 - `setInProgress` / `setDone` / `setError` / `setConflicted` — single marker `{ type, value }` or `{ apply: [...] }` for multi-marker.
-- `clearConflicted` — labels to remove once a conflicted PR is fixed (status removal is not supported).
+- `clearConflicted` / `clearReview` — labels to remove once a conflicted PR is fixed or a review-mode issue is picked back up (status removal is not supported).
+
+**Review follow-ups.** When a Linear issue is in a "done" state and a reviewer adds the `getReview` marker (typically a label like `ralph:review` after leaving comments), Ralph picks it up, applies `setInProgress`, removes the `clearReview` label so the same trigger doesn't re-fire, fetches the comment thread, filters out Ralph's own comments, and prepends those reviewer comments as a new task at the top of `tasks.md`. The worker addresses them in the same change branch and `setDone` is re-applied on success.
+
+**`@ralphy` mention trigger.** Set `linear.mentionTrigger: true` (default `false`) to scan done-issue comments on both Linear and their linked GitHub PR for `@ralphy` mentions (configurable via `linear.mentionHandle`). New mentions enqueue the issue as a review run with the mention text used verbatim as the prepended task. Idempotency: a mention is considered processed when its `createdAt` is older than the most recent Ralph `🔁 picked up` comment on the Linear issue, so the same comment never re-fires across polls. Requires the `gh` CLI authenticated for the GitHub side.
 
 Marker types are `"label"` or `"status"`. Combine markers under `apply` when one event needs to set multiple — e.g. `setDone` flipping a status _and_ adding a "shipped" label.
 

package/dist/cli/index.js

@@ -35029,8 +35029,8 @@ import { readFileSync as readFileSync2 } from "fs";
 import { resolve } from "path";
 function getVersion() {
   try {
-    if ("2.17.3")
-      return "2.17.3";
+    if ("2.19.0")
+      return "2.19.0";
   } catch {}
   const dirsToTry = [];
   try {
@@ -35356,13 +35356,20 @@ var init_cli = __esm(() => {
     "getTodo",
     "getInProgress",
     "getConflicted",
+    "getReview",
     "setInProgress",
     "setDone",
     "setError",
     "setConflicted",
-    "clearConflicted"
+    "clearConflicted",
+    "clearReview"
+  ]);
+  GET_KEYS = new Set([
+    "getTodo",
+    "getInProgress",
+    "getConflicted",
+    "getReview"
   ]);
-  GET_KEYS = new Set(["getTodo", "getInProgress", "getConflicted"]);
   HELP_TEXT = [
     `ralph v${VERSION}`,
     "",
@@ -35404,8 +35411,9 @@ var init_cli = __esm(() => {
     "                          --indicator getTodo:status:Todo",
     "                          --indicator setDone:label:shipped",
     "                          --indicator setDone:status:Done   (combined with above \u2192 multi-marker)",
-    "                          Keys: getTodo, getInProgress, getConflicted,",
-    "                                setInProgress, setDone, setError, setConflicted, clearConflicted",
+    "                          Keys: getTodo, getInProgress, getConflicted, getReview,",
+    "                                setInProgress, setDone, setError, setConflicted,",
+    "                                clearConflicted, clearReview",
     "                          Types: label, status",
     "  --create-pr             Push the worker branch and open a GitHub PR on success (needs --worktree)",
     "  --fix-ci                After opening the PR, re-run on CI failures until green (needs --create-pr)",
@@ -59613,6 +59621,12 @@ var MarkerSchema, GetIndicatorSchema, SetIndicatorSchema, IndicatorsSchema, Ralp
     // Post a progress update every N iterations. 0 disables. Requires postComments.
     "updateEveryIterations": 10,
 
+    // Watch done-issue Linear comments AND their linked GitHub PR comments
+    // for "@ralphy" mentions. New mentions enqueue the issue as a review run
+    // with the mention text as the prepended task.
+    "mentionTrigger": false,
+    // "mentionHandle": "@ralphy",
+
     // Indicators map Ralph lifecycle events to Linear labels/statuses.
     // WARNING: activating indicators will query AND mutate your Linear workspace.
     // Uncomment each entry after confirming the label/status names match your workspace.
@@ -59626,6 +59640,10 @@ var MarkerSchema, GetIndicatorSchema, SetIndicatorSchema, IndicatorsSchema, Ralp
       // Issues whose PR has a merge conflict (Ralph will attempt a re-fix run).
       // "getConflicted": { "filter": [{ "type": "label", "value": "ralph:conflict" }] },
 
+      // Done issues with new review comments to address (Ralph will re-open
+      // and prepend a task that ingests the non-Ralph comments).
+      // "getReview": { "filter": [{ "type": "label", "value": "ralph:review" }] },
+
       // Applied when Ralph picks up an issue.
       // "setInProgress": { "type": "label", "value": "ralph:in-progress" },
 
@@ -59639,7 +59657,10 @@ var MarkerSchema, GetIndicatorSchema, SetIndicatorSchema, IndicatorsSchema, Ralp
       // "setConflicted": { "type": "label", "value": "ralph:conflict" },
 
       // Label removed once the conflict is fixed (status removal is not supported here).
-      // "clearConflicted": { "type": "label", "value": "ralph:conflict" }
+      // "clearConflicted": { "type": "label", "value": "ralph:conflict" },
+
+      // Label removed when Ralph picks up a review-mode issue (status removal not supported).
+      // "clearReview": { "type": "label", "value": "ralph:review" }
     }
   }
 }
@@ -59661,24 +59682,28 @@ var init_config = __esm(() => {
     getTodo: GetIndicatorSchema.optional(),
     getInProgress: GetIndicatorSchema.optional(),
     getConflicted: GetIndicatorSchema.optional(),
+    getReview: GetIndicatorSchema.optional(),
     setInProgress: SetIndicatorSchema.optional(),
     setDone: SetIndicatorSchema.optional(),
     setError: SetIndicatorSchema.optional(),
     setConflicted: SetIndicatorSchema.optional(),
-    clearConflicted: SetIndicatorSchema.optional()
+    clearConflicted: SetIndicatorSchema.optional(),
+    clearReview: SetIndicatorSchema.optional()
   }).superRefine((value, ctx) => {
-    const clear = value.clearConflicted;
-    if (!clear)
-      return;
-    const markers = "apply" in clear ? clear.apply : [clear];
-    for (const m of markers) {
-      if (m.type !== "label") {
-        ctx.addIssue({
-          code: exports_external.ZodIssueCode.custom,
-          path: ["clearConflicted"],
-          message: "clearConflicted markers must be label-typed (status removal is not supported)"
-        });
-        return;
+    for (const key of ["clearConflicted", "clearReview"]) {
+      const clear = value[key];
+      if (!clear)
+        continue;
+      const markers = "apply" in clear ? clear.apply : [clear];
+      for (const m of markers) {
+        if (m.type !== "label") {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: [key],
+            message: `${key} markers must be label-typed (status removal is not supported)`
+          });
+          break;
+        }
       }
     }
   });
@@ -59711,8 +59736,16 @@ var init_config = __esm(() => {
       assignee: exports_external.string().optional(),
       postComments: exports_external.boolean().default(true),
       updateEveryIterations: exports_external.number().int().nonnegative().default(10),
+      mentionTrigger: exports_external.boolean().default(false),
+      mentionHandle: exports_external.string().default("@ralphy"),
       indicators: IndicatorsSchema.default({})
-    }).strict().default({ postComments: true, updateEveryIterations: 10, indicators: {} })
+    }).strict().default({
+      postComments: true,
+      updateEveryIterations: 10,
+      mentionTrigger: false,
+      mentionHandle: "@ralphy",
+      indicators: {}
+    })
   }).default({
     concurrency: 1,
     pollIntervalSeconds: 60,
@@ -59721,7 +59754,13 @@ var init_config = __esm(() => {
     enableManualTest: false,
     engine: "claude",
     model: "opus",
-    linear: { postComments: true, updateEveryIterations: 10, indicators: {} }
+    linear: {
+      postComments: true,
+      updateEveryIterations: 10,
+      mentionTrigger: false,
+      mentionHandle: "@ralphy",
+      indicators: {}
+    }
   });
 });
 
@@ -60050,19 +60089,23 @@ class AgentCoordinator {
     let todo = [];
     let inProgress = [];
     let conflicted = [];
+    let review = [];
+    let mentions = [];
     try {
-      [todo, inProgress, conflicted] = await Promise.all([
+      [todo, inProgress, conflicted, review, mentions] = await Promise.all([
         this.deps.fetchTodo(),
         this.deps.fetchInProgress(),
-        this.deps.fetchConflicted()
+        this.deps.fetchConflicted(),
+        this.deps.fetchReview(),
+        this.deps.fetchMentions()
       ]);
     } catch (err) {
       this.deps.onLog(`! Linear poll failed: ${err.message}`, "red");
       capture("agent_linear_poll_failed", { error: err.message });
       return { found: 0, added: 0 };
     }
-    if (todo.length + inProgress.length + conflicted.length > 0) {
-      this.deps.onLog(`  poll: ${todo.length} todo, ${inProgress.length} in-progress, ${conflicted.length} conflicted`, "gray");
+    if (todo.length + inProgress.length + conflicted.length + review.length + mentions.length > 0) {
+      this.deps.onLog(`  poll: ${todo.length} todo, ${inProgress.length} in-progress, ${conflicted.length} conflicted, ${review.length} review, ${mentions.length} mention`, "gray");
     }
     const queuedIds = new Set(this.queue.map((q) => q.issue.id));
     const activeIds = new Set(this.workers.map((w) => w.issueId));
@@ -60097,6 +60140,26 @@ class AgentCoordinator {
       added += 1;
       this.deps.onLog(`  \u21B3 ${issue.identifier} queued (conflict-fix)`, "gray");
     }
+    for (const issue of review) {
+      if (atTicketLimit())
+        break;
+      if (!eligible(issue.id))
+        continue;
+      this.queue.push({ issue, mode: "review" });
+      queuedIds.add(issue.id);
+      added += 1;
+      this.deps.onLog(`  \u21B3 ${issue.identifier} queued (review)`, "gray");
+    }
+    for (const { issue, trigger } of mentions) {
+      if (atTicketLimit())
+        break;
+      if (!eligible(issue.id))
+        continue;
+      this.queue.push({ issue, mode: "review", trigger });
+      queuedIds.add(issue.id);
+      added += 1;
+      this.deps.onLog(`  \u21B3 ${issue.identifier} queued (review via ${trigger.source} mention)`, "gray");
+    }
     for (const issue of todo) {
       if (atTicketLimit())
         break;
@@ -60113,7 +60176,8 @@ class AgentCoordinator {
       const modeRank = {
         resume: 0,
         "conflict-fix": 1,
-        fresh: 2
+        review: 2,
+        fresh: 3
       };
       this.queue.sort((a, b) => {
         const pa = a.issue.priority === 0 ? Infinity : a.issue.priority;
@@ -60126,7 +60190,7 @@ class AgentCoordinator {
     this.spawnNext();
     await this.scanDoneForConflicts();
     await this.reportProgress();
-    const found = todo.length + inProgress.length + conflicted.length;
+    const found = todo.length + inProgress.length + conflicted.length + review.length + mentions.length;
     return { found, added };
   }
   dependenciesResolved(issue) {
@@ -60235,13 +60299,13 @@ class AgentCoordinator {
     while (this.workers.length + this.pendingIds.size < this.opts.concurrency && this.queue.length > 0) {
       const next = this.queue.shift();
       this.pendingIds.add(next.issue.id);
-      this.launchWorker(next.issue, next.mode);
+      this.launchWorker(next.issue, next.mode, next.trigger);
     }
   }
-  async launchWorker(issue, mode) {
+  async launchWorker(issue, mode, trigger) {
     let prep;
     try {
-      prep = await this.deps.prepare(issue, mode);
+      prep = await this.deps.prepare(issue, mode, trigger);
     } catch (err) {
       this.pendingIds.delete(issue.id);
       this.deps.onLog(`! prepare(${mode}) failed for ${issue.identifier}: ${err.message}`, "red");
@@ -60270,6 +60334,27 @@ class AgentCoordinator {
         });
       }
     }
+    if (mode === "review" && this.opts.clearReview) {
+      try {
+        await this.deps.removeIndicator(issue, this.opts.clearReview);
+        this.deps.onLog(`  ${issue.identifier}: clearReview applied`, "gray");
+      } catch (err) {
+        this.deps.onLog(`! Linear clearReview failed for ${issue.identifier}: ${err.message}`, "yellow");
+        capture("agent_indicator_failed", {
+          indicator: "clearReview",
+          issue_identifier: issue.identifier,
+          error: err.message
+        });
+      }
+    }
+    if (mode === "review" && this.opts.postComments !== false) {
+      const sourceTag = trigger ? trigger.source === "github" ? " (GitHub @mention)" : " (Linear @mention)" : "";
+      try {
+        await this.deps.postComment(issue, `\uD83D\uDD01 Ralph picked up new review comments${sourceTag}. Tracking change: \`${prep.changeName}\``);
+      } catch (err) {
+        this.deps.onLog(`! Linear review comment failed for ${issue.identifier}: ${err.message}`, "yellow");
+      }
+    }
     if (mode === "fresh" && this.opts.postComments !== false) {
       let alreadyPosted = false;
       try {
@@ -61032,6 +61117,49 @@ function mergeIndicators(cfg, cli) {
   }
   return out;
 }
+function isRalphComment(body) {
+  const trimmed = body.trimStart();
+  return /^(\uD83E\uDD16|\uD83D\uDD04|\u2705|\u2717|\u26A0|\uD83D\uDD01)\s*Ralph\b/.test(trimmed);
+}
+function buildReviewTaskBody(comments, url) {
+  if (comments.length === 0) {
+    return `No non-Ralph reviewer comments were found on ${url}. Recheck the issue manually before continuing.`;
+  }
+  const blocks = comments.map((c) => {
+    const author = c.user?.name ?? "unknown";
+    return `**${author}** \u2014 ${c.createdAt}
+
+${c.body.trim()}`;
+  });
+  return [
+    `Reviewer comments left on the Linear issue (${url}):`,
+    "",
+    ...blocks,
+    "",
+    "Address every concrete request above. If a comment is ambiguous, note",
+    "your interpretation in proposal.md `## Steering` before acting."
+  ].join(`
+`);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildMentionTaskBody(trigger, issueUrl) {
+  const sourceLabel = trigger.source === "github" ? "GitHub PR" : "Linear issue";
+  const permalink = trigger.url ?? issueUrl;
+  const header = `${trigger.author ?? "unknown"} \u2014 ${trigger.createdAt} (${sourceLabel})`;
+  return [
+    `An @ralphy mention was left on ${sourceLabel} (${permalink}):`,
+    "",
+    `**${header}**`,
+    "",
+    trigger.body.trim(),
+    "",
+    "Treat this comment as the next concrete request. If it's ambiguous,",
+    "note your interpretation in proposal.md `## Steering` before acting."
+  ].join(`
+`);
+}
 function unionMarkers(...sets) {
   const out = [];
   const seen = new Set;
@@ -61071,6 +61199,7 @@ function buildAgentCoordinator(input) {
   const team = args.linearTeam || cfg.linear.team;
   const assignee = args.linearAssignee || cfg.linear.assignee;
   const excludeFromTodo = unionMarkers(indicators.setDone, indicators.setError, indicators.setConflicted);
+  const excludeFromReview = unionMarkers(indicators.setInProgress, indicators.setError, indicators.setConflicted);
   const gitRunner = input.runners?.git ?? bunGitRunner;
   const cmdRunner = input.runners?.cmd ?? bunCmdRunner;
   const stateCache = new Map;
@@ -61241,10 +61370,11 @@ function buildAgentCoordinator(input) {
     }
     return { workerCwd, scaffoldTasksDir, scaffoldStatesDir, branch };
   }
-  async function prepare(issue, mode) {
+  async function prepare(issue, mode, trigger) {
     const { workerCwd, scaffoldTasksDir, scaffoldStatesDir, branch } = await setupWorktree(issue);
     let changeName;
-    if (mode === "fresh") {
+    const isFresh = mode === "fresh";
+    if (isFresh) {
       let comments = [];
       try {
         comments = await fetchIssueComments(apiKey, issue.id);
@@ -61264,7 +61394,32 @@ function buildAgentCoordinator(input) {
     issueByChange.set(changeName, issue);
     if (branch)
       branchByChange.set(changeName, branch);
-    if (mode === "conflict-fix") {
+    if (mode === "review") {
+      const wtLayout = projectLayout(workerCwd);
+      const tasksFile = join16(wtLayout.changeDir(changeName), "tasks.md");
+      let body;
+      let heading;
+      if (trigger) {
+        heading = trigger.source === "github" ? "Address GitHub @ralphy mention" : "Address Linear @ralphy mention";
+        body = buildMentionTaskBody(trigger, issue.url);
+      } else {
+        heading = "Address reviewer comments";
+        let comments = [];
+        try {
+          comments = await fetchIssueComments(apiKey, issue.id);
+        } catch (err) {
+          onLog(`! Linear comment fetch failed for ${issue.identifier}: ${err.message}`, "yellow");
+        }
+        const reviewerComments = comments.filter((c) => !isRalphComment(c.body));
+        body = buildReviewTaskBody(reviewerComments, issue.url);
+      }
+      try {
+        await prependFixTask(tasksFile, heading, body);
+      } catch (err) {
+        onLog(`! could not prepend review task: ${err.message}`, "red");
+      }
+      await reactivateState2(wtLayout.stateFile(changeName), changeName);
+    } else if (mode === "conflict-fix") {
       const wtLayout = projectLayout(workerCwd);
       const tasksFile = join16(wtLayout.changeDir(changeName), "tasks.md");
       const prUrl = prByChange.get(changeName);
@@ -61535,10 +61690,145 @@ PR: ${prUrl}` : ""
       return [];
     return fetchOpenIssues(apiKey, { team, assignee, include, exclude });
   }
+  async function fetchMentions() {
+    if (!cfg.linear.mentionTrigger)
+      return [];
+    const handle = cfg.linear.mentionHandle;
+    let candidates = [];
+    try {
+      candidates = await fetchDoneCandidates();
+    } catch (err) {
+      onLog(`! mention scan: fetchDoneCandidates failed: ${err.message}`, "yellow");
+      return [];
+    }
+    const out = [];
+    for (const issue of candidates) {
+      let comments = [];
+      try {
+        comments = await fetchIssueComments(apiKey, issue.id);
+      } catch (err) {
+        onLog(`! mention scan: Linear comments failed for ${issue.identifier}: ${err.message}`, "yellow");
+        continue;
+      }
+      const lastRalphPickup = findLastRalphPickupISO(comments);
+      for (const c of comments) {
+        if (isRalphComment(c.body))
+          continue;
+        if (!containsHandle(c.body, handle))
+          continue;
+        if (lastRalphPickup && c.createdAt <= lastRalphPickup)
+          continue;
+        out.push({
+          issue,
+          trigger: {
+            source: "linear",
+            body: c.body,
+            createdAt: c.createdAt,
+            ...c.user?.name ? { author: c.user.name } : {},
+            url: issue.url
+          }
+        });
+        break;
+      }
+      if (out.length > 0 && out[out.length - 1].issue.id === issue.id)
+        continue;
+      const prUrl = await resolvePrUrlForIssue(issue);
+      if (!prUrl)
+        continue;
+      const ghComments = await fetchPrIssueComments(prUrl);
+      for (const c of ghComments) {
+        if (!containsHandle(c.body, handle))
+          continue;
+        if (lastRalphPickup && c.createdAt <= lastRalphPickup)
+          continue;
+        out.push({
+          issue,
+          trigger: {
+            source: "github",
+            body: c.body,
+            createdAt: c.createdAt,
+            ...c.author ? { author: c.author } : {},
+            url: c.url
+          }
+        });
+        break;
+      }
+    }
+    return out;
+  }
+  function findLastRalphPickupISO(comments) {
+    let latest = null;
+    for (const c of comments) {
+      if (!/^\uD83D\uDD01\s*Ralph picked up/.test(c.body.trimStart()))
+        continue;
+      if (latest === null || c.createdAt > latest)
+        latest = c.createdAt;
+    }
+    return latest;
+  }
+  function containsHandle(body, handle) {
+    const re = new RegExp(`(^|\\s|[^A-Za-z0-9_])${escapeRegex(handle)}\\b`, "i");
+    return re.test(body);
+  }
+  async function resolvePrUrlForIssue(issue) {
+    const changeName = changeNameForIssue(issue);
+    if (prUnavailable.has(changeName))
+      return null;
+    const cached = prByChange.get(changeName);
+    if (cached)
+      return cached;
+    const branch = branchForChange(changeName);
+    try {
+      const res = await cmdRunner.run([
+        "gh",
+        "pr",
+        "list",
+        "--head",
+        branch,
+        "--state",
+        "all",
+        "--json",
+        "url",
+        "--jq",
+        ".[0].url // empty"
+      ], projectRoot);
+      const found = res.stdout.trim();
+      if (!found) {
+        prUnavailable.add(changeName);
+        return null;
+      }
+      prByChange.set(changeName, found);
+      return found;
+    } catch {
+      return null;
+    }
+  }
+  async function fetchPrIssueComments(prUrl) {
+    const m = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/.exec(prUrl);
+    if (!m)
+      return [];
+    const [, owner, repo, num] = m;
+    try {
+      const res = await cmdRunner.run([
+        "gh",
+        "api",
+        `repos/${owner}/${repo}/issues/${num}/comments`,
+        "--jq",
+        "[.[] | {body: .body, createdAt: .created_at, author: .user.login, url: .html_url}]"
+      ], projectRoot);
+      const parsed = JSON.parse(res.stdout || "[]");
+      return parsed;
+    } catch (err) {
+      onLog(`! mention scan: gh comments failed for ${prUrl}: ${err.message}`, "yellow");
+      return [];
+    }
+  }
   const coord = new AgentCoordinator({
     fetchTodo: () => fetchByGet(indicators.getTodo, excludeFromTodo),
     fetchInProgress: () => fetchByGet(indicators.getInProgress, []),
     fetchConflicted: () => fetchByGet(indicators.getConflicted, []),
+    fetchReview: () => fetchByGet(indicators.getReview, excludeFromReview),
+    fetchMentions,
     fetchDoneCandidates,
     prepare,
     spawnWorker,
@@ -61567,6 +61857,7 @@ PR: ${prUrl}` : ""
     ...indicators.setError !== undefined ? { setError: indicators.setError } : {},
     ...indicators.setConflicted !== undefined ? { setConflicted: indicators.setConflicted } : {},
     ...indicators.clearConflicted !== undefined ? { clearConflicted: indicators.clearConflicted } : {},
+    ...indicators.clearReview !== undefined ? { clearReview: indicators.clearReview } : {},
     postComments: cfg.linear.postComments,
     commentEveryIterations: cfg.linear.updateEveryIterations,
     ...args.maxTickets > 0 ? { maxTickets: args.maxTickets } : {}
@@ -61593,6 +61884,9 @@ function describeIndicators(indicators, team, assignee) {
   if (indicators.getConflicted) {
     parts.push(`conflicted=[${indicators.getConflicted.filter.map((m) => `${m.type}:${m.value}`).join(",")}]`);
   }
+  if (indicators.getReview) {
+    parts.push(`review=[${indicators.getReview.filter.map((m) => `${m.type}:${m.value}`).join(",")}]`);
+  }
   return parts.join(", ");
 }
 var bunGitRunner, bunCmdRunner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neriros/ralphy",
-  "version": "2.17.3",
+  "version": "2.19.0",
   "description": "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   "keywords": [
     "agent",