@link-assistant/hive-mind 2.19.1 → 2.20.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @link-assistant/hive-mind
 
+## 2.20.0
+
+### Minor Changes
+
+- 84ea8a3: Accept a repository URL in `solve` and close every open issue of that repository with one pull request, and add `--ensure-all-sub-issues-addressed` to prove it (issue #2212).
+
+  `solve https://github.com/owner/repo` used to be rejected: `validateGitHubUrl` only ever accepted an issue or a pull request URL. It now means something. Repository mode lists every open issue of the repository, creates one combined issue that lists them as GitHub **native sub-issues**, and hands that issue to the normal single-issue flow — so a single pull request can close all of them at once, and merging it closes the combined issue too.
+
+  - **The combined issue is built from what GitHub actually allows.** A parent issue takes at most 100 sub-issues, so a repository with more open issues gets the oldest 100 and the rest are reported as intentionally left out — in the run log and in the issue body, not silently. Pull requests are filtered out of the REST `/issues` response, the selection is oldest-first with the issue number as tie-breaker, and each issue is attached with its REST database id through `POST …/sub_issues`. That endpoint is documented as prone to secondary rate limiting, so attachments are spaced one second apart and a rate-limited attachment is retried with a one- then two-minute backoff; an attachment that fails for any other reason (an issue that already has a parent, say) is reported and skipped instead of aborting the run.
+  - **`--ensure-all-sub-issues-addressed` works on any issue.** After the main solve completes it lists the sub-issues of the issue being solved and checks the pull request title and description for a closing reference GitHub really recognizes — reusing `prClosesIssue`, so `Fixes #1, #2` correctly counts as closing only `#1`, exactly as GitHub reads it. When references are missing it restarts the AI tool with the concrete list of sub-issues and the exact lines to add, asking it to double check that each one was really addressed in this single pull request. Bare flag means 5 restarts; it also takes a count or `forever`. It runs last among the post-solve loops, because `--escalate`, `--auto-ensure-requirements` and `--keep-working` may still rewrite the description.
+  - **Repository mode turns on `--deep-analysis` and `--ensure-all-sub-issues-addressed` for the issue it generated**, so the run asks for the deep analysis `/fix` asks for and then verifies its own promise.
+  - **The Telegram bot accepts repository URLs in `/solve` too**, and labels such a run as a URL rather than as an issue.
+
+  `tests/test-solve-repository-mode-2212.mjs` (47 assertions) covers the rejection this starts from, the pure helpers, the orchestration against a fake `gh`, the CLI flag and the `solve.mjs` wiring; `tests/test-telegram-solve-repository-url-2212.mjs` (25 assertions) covers the Telegram entry point. `examples/solve-repository-mode-preview.mjs` previews a real repository read-only, creating nothing. The analysis, the cited GitHub documentation and the run evidence are in `docs/case-studies/issue-2212/`.
+
+## 2.19.2
+
+### Patch Changes
+
+- 57b8258: Never merge hive-mind's own placeholder file, and restart when a pull request changes nothing.
+
+  `konard/audio-decomposer#1` was solved twice, both pull requests were auto-merged, and the complete diff of both was the `.gitkeep` hive-mind writes only so that an empty branch has something to open a pull request from. Two defects had to line up for that, and both are fixed here.
+
+  - **The placeholder is reverted before anything can merge it.** `cleanupClaudeFile()` ran after `startAutoRestartUntilMergeable()`, so with `--auto-merge` it was structurally guaranteed to be too late: on that pull request the revert commit is timestamped four seconds after the merge commit. It now runs before the watch loop and still after `verifyResults()`, which is the ordering issue #1516 actually asked for. As defense in depth, the watch loop reverts a placeholder that survived into its own diff — a crashed session, a resumed run — instead of merging it.
+  - **An appended placeholder is recognised as a placeholder.** The empty-pull-request detector matched an added `# .gitkeep file auto-generated at …` line, which the solver only writes when it _creates_ the file; when the file already exists it appends `# Updated: <timestamp>` instead, and that reads as an ordinary modification. The diff was counted as real work, so the pull request looked mergeable and the auto-restart from issue #2119 never fired. The measurement now reconstructs both sides of the file and compares them with hive-mind's own generated lines removed, so created, appended and re-appended placeholders are all caught — while a genuine edit to a `.gitkeep` or `CLAUDE.md` the repository owns still counts as work.
+
+  The leak was not a one-off: `.gitkeep` on the default branch of `link-foundation/rust-ai-driven-development-pipeline-template` had accumulated eight solver-generated lines from eight merged pull requests, one of which also carried real changes. Each miss makes the next one certain, because a surviving file forces the append path that the detector could not see. The full reconstruction is in `docs/case-studies/issue-2211`.
+
 ## 2.19.1
 
 ### Patch Changes

package/README.hi.md

@@ -322,6 +322,9 @@ solve https://github.com/owner/repo/issues/123 --base-branch develop --fork
 # Continue working on existing PR
 solve https://github.com/owner/repo/pull/456 --model opus
 
+# Solve every open issue of a repository with one pull request (repository mode)
+solve https://github.com/owner/repo
+
 # Resume from Claude session when limit is reached
 solve https://github.com/owner/repo/issues/123 --resume session-id
 
@@ -354,6 +357,8 @@ review --repo owner/repo --pr 456
 solve <issue-url> [options]
 ```
 
+> **📦 Repository mode**: issue URL की जगह repository URL दें — solve उस repository के सभी open issues इकट्ठा करता है (सबसे पुराने पहले, अधिकतम 100 — GitHub की प्रति parent sub-issue सीमा), उन्हें GitHub native sub-issues के रूप में सूचीबद्ध करने वाला एक संयुक्त issue बनाता है, और उसी issue को हल करता है — ताकि एक ही pull request उन सबको एक साथ बंद कर सके। यह `--deep-analysis` और `--ensure-all-sub-issues-addressed` को भी चालू कर देता है। देखें [docs/CONFIGURATION.md](./docs/CONFIGURATION.md#solve-options)।
+
 **सबसे अधिक उपयोग किए जाने वाले विकल्प:**
 
 | विकल्प          | संक्षिप्त | विवरण                                                     | डिफ़ॉल्ट   |

package/README.md

@@ -328,6 +328,9 @@ solve https://github.com/owner/repo/issues/123 --base-branch develop --fork
 # Continue working on existing PR
 solve https://github.com/owner/repo/pull/456 --model opus
 
+# Solve every open issue of a repository with one pull request (repository mode)
+solve https://github.com/owner/repo
+
 # Resume from Claude session when limit is reached
 solve https://github.com/owner/repo/issues/123 --resume session-id
 
@@ -360,6 +363,8 @@ review --repo owner/repo --pr 456
 solve <issue-url> [options]
 ```
 
+> **📦 Repository mode**: pass a repository URL instead of an issue URL and solve collects every open issue of that repository (oldest first, at most 100 — GitHub's sub-issue limit per parent), creates one combined issue that lists them as GitHub native sub-issues, and solves that issue — so a single pull request can close all of them at once. It also turns on `--deep-analysis` and `--ensure-all-sub-issues-addressed`. See [docs/CONFIGURATION.md](./docs/CONFIGURATION.md#solve-options).
+
 **Most frequently used options:**
 
 | Option          | Alias | Description                             | Default   |

package/README.ru.md

@@ -322,6 +322,9 @@ solve https://github.com/owner/repo/issues/123 --base-branch develop --fork
 # Continue working on existing PR
 solve https://github.com/owner/repo/pull/456 --model opus
 
+# Solve every open issue of a repository with one pull request (repository mode)
+solve https://github.com/owner/repo
+
 # Resume from Claude session when limit is reached
 solve https://github.com/owner/repo/issues/123 --resume session-id
 
@@ -354,6 +357,8 @@ review --repo owner/repo --pr 456
 solve <issue-url> [options]
 ```
 
+> **📦 Режим репозитория**: передайте URL репозитория вместо URL задачи — solve соберёт все открытые задачи этого репозитория (сначала самые старые, не более 100 — это лимит GitHub на количество под-задач у одной родительской задачи), создаст одну сводную задачу, где они перечислены как нативные под-задачи GitHub, и будет решать её — так что один pull request сможет закрыть их все сразу. Режим также включает `--deep-analysis` и `--ensure-all-sub-issues-addressed`. См. [docs/CONFIGURATION.md](./docs/CONFIGURATION.md#solve-options).
+
 **Наиболее часто используемые параметры:**
 
 | Параметр        | Сокр. | Описание                                                     | По умолчанию   |

package/README.zh.md

@@ -322,6 +322,9 @@ solve https://github.com/owner/repo/issues/123 --base-branch develop --fork
 # Continue working on existing PR
 solve https://github.com/owner/repo/pull/456 --model opus
 
+# Solve every open issue of a repository with one pull request (repository mode)
+solve https://github.com/owner/repo
+
 # Resume from Claude session when limit is reached
 solve https://github.com/owner/repo/issues/123 --resume session-id
 
@@ -354,6 +357,8 @@ review --repo owner/repo --pr 456
 solve <issue-url> [options]
 ```
 
+> **📦 仓库模式**：传入仓库 URL（而不是 issue URL），solve 会收集该仓库的所有开放 issue（最旧优先，最多 100 个 —— GitHub 每个父 issue 的子 issue 上限），创建一个把它们列为 GitHub 原生子 issue 的合并 issue，并解决该 issue —— 这样一个 pull request 就能一次性关闭它们全部。该模式还会自动启用 `--deep-analysis` 和 `--ensure-all-sub-issues-addressed`。参见 [docs/CONFIGURATION.md](./docs/CONFIGURATION.md#solve-options)。
+
 **最常用选项：**
 
 | 选项            | 简写 | 描述                                                  | 默认值   |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.19.1",
+  "version": "2.20.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/pull-request-changes.lib.mjs

@@ -48,20 +48,140 @@ import { quietProbe } from './quiet-probe.lib.mjs';
 const LARGE_DIFF_WARNING_BYTES = 8 * 1024 * 1024;
 
 /**
- * The solver's own scaffolding files, recognised by the content it writes into
- * them (`src/solve.auto-pr.lib.mjs`). A pull request whose whole diff is one of
- * these contains no solution: the placeholder exists only to give an empty
- * branch something to open a pull request from, and is reverted once the AI
- * commits real work.
- *
- * Matching on content, not on the file name, keeps a repository's own
- * `.gitkeep` or `CLAUDE.md` edits counted as the real changes they are.
+ * The solver's own scaffolding files (`src/solve.auto-pr.lib.mjs`). A pull
+ * request whose whole diff is one of these contains no solution: the
+ * placeholder exists only to give an empty branch something to open a pull
+ * request from, and is reverted once the AI commits real work.
+ *
+ * Issue #2211: asking "did the diff *add* the auto-generated header line?" only
+ * recognised the case where the solver created the file. When the repository
+ * already tracks a `.gitkeep` - the normal state of every repository generated
+ * from a template whose own solver run leaked one - `solve.auto-pr.lib.mjs`
+ * appends `# Updated: <timestamp>` instead, so the header is a context line, no
+ * pattern matched, and a pull request whose entire diff was that one timestamp
+ * measured as one changed file and was auto-merged:
+ *
+ *   https://github.com/konard/audio-decomposer/pull/3
+ *   .gitkeep | 2 +-
+ *
+ * The question asked here is therefore the one that actually decides it: once
+ * the solver's own generated lines are removed from both sides of the diff, is
+ * the file unchanged? That answers "created", "appended to" and "appended to
+ * again" with one rule, and it still counts a repository's own `.gitkeep` or
+ * `CLAUDE.md` edits as the real changes they are - a change to any line the
+ * solver did not write makes the two sides differ.
  */
-const PLACEHOLDER_CONTENT_PATTERNS = new Map([
-  ['.gitkeep', [/^\+#\s*\.gitkeep file auto-generated at .+ for PR creation at branch /m]],
-  ['CLAUDE.md', [/^\+Issue to solve: \S+/m, /^\+Your prepared branch: \S+/m]],
+
+/** Lines `solve.auto-pr.lib.mjs` writes into `.gitkeep`. */
+const GITKEEP_GENERATED_LINE_PATTERNS = [/^#\s*\.gitkeep file auto-generated at \S+ for PR creation at branch \S+ for issue \S+\s*$/, /^#\s*Updated: \d{4}-\d{2}-\d{2}T[\d:.]+Z?\s*$/];
+
+/** The line that opens the task block `solve.auto-pr.lib.mjs` writes into `CLAUDE.md`. */
+const CLAUDE_MD_TASK_BLOCK_HEAD = /^Issue to solve: \S+\s*$/;
+
+/** Lines of that task block, including the ones only `--fork` runs emit. */
+const CLAUDE_MD_GENERATED_LINE_PATTERNS = [CLAUDE_MD_TASK_BLOCK_HEAD, /^Your prepared branch: \S+\s*$/, /^Your prepared working directory: \S+\s*$/, /^Your forked repository: \S+\s*$/, /^Original repository \(upstream\): \S+\s*$/, /^Proceed\.\s*$/, /^Run timestamp: \d{4}-\d{2}-\d{2}T[\d:.]+Z?\s*$/];
+
+const PLACEHOLDER_GENERATED_LINES = new Map([
+  ['.gitkeep', GITKEEP_GENERATED_LINE_PATTERNS],
+  ['CLAUDE.md', CLAUDE_MD_GENERATED_LINE_PATTERNS],
 ]);
 
+/**
+ * Rebuild both sides of one file's unified-diff section.
+ *
+ * Only the hunks are read: everything before the first `@@` is git's own header
+ * (`index`, `new file mode`, `--- a/x`, `+++ b/x`) and belongs to neither side,
+ * and `` is a note about the previous line, not a
+ * line of the file.
+ *
+ * Context outside the hunks is missing from both sides equally, which is all the
+ * caller needs: it compares the two reconstructions against each other.
+ *
+ * @param {string} body - the section text, hunk headers included.
+ * @returns {{oldLines: string[], newLines: string[]}}
+ */
+const reconstructSides = body => {
+  const oldLines = [];
+  const newLines = [];
+  let inHunk = false;
+  for (const line of body.split('\n')) {
+    if (line.startsWith('@@')) {
+      inHunk = true;
+      continue;
+    }
+    if (!inHunk || line.startsWith('\\')) continue;
+    const text = line.slice(1);
+    if (line[0] === '-') oldLines.push(text);
+    else if (line[0] === '+') newLines.push(text);
+    else {
+      // ' ' is a context line; a completely empty line is a context line whose
+      // content is empty (git omits the trailing space on some diffs).
+      oldLines.push(text);
+      newLines.push(text);
+    }
+  }
+  return { oldLines, newLines };
+};
+
+/**
+ * True when the first non-blank line at or after `from` opens the CLAUDE.md
+ * task block, i.e. the preceding `---` is the separator the solver writes
+ * rather than a horizontal rule a human wrote.
+ */
+const opensClaudeTaskBlock = (lines, from) => {
+  for (let i = from; i < lines.length; i++) {
+    if (lines[i].trim() === '') continue;
+    return CLAUDE_MD_TASK_BLOCK_HEAD.test(lines[i]);
+  }
+  return false;
+};
+
+/**
+ * Drop every line the solver generated, leaving whatever the repository owns.
+ *
+ * @returns {{kept: string[], removed: number}}
+ */
+const stripGeneratedLines = (path, lines) => {
+  const patterns = PLACEHOLDER_GENERATED_LINES.get(path) || [];
+  const kept = [];
+  let removed = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (patterns.some(pattern => pattern.test(line))) {
+      removed += 1;
+      continue;
+    }
+    // The CLAUDE.md append path writes "\n\n---\n\n" ahead of the task block;
+    // that separator is generated too, but only in that position.
+    if (path === 'CLAUDE.md' && /^-{3,}\s*$/.test(line) && opensClaudeTaskBlock(lines, i + 1)) {
+      removed += 1;
+      continue;
+    }
+    kept.push(line);
+  }
+  return { kept, removed };
+};
+
+/**
+ * Is this section nothing but the solver's placeholder bookkeeping?
+ *
+ * @param {string|null} path - the file's path, or null when it is not a
+ *   placeholder candidate.
+ * @param {string} body - the section text.
+ * @returns {boolean}
+ */
+const isPlaceholderSection = (path, body) => {
+  if (!PLACEHOLDER_GENERATED_LINES.has(path)) return false;
+  const { oldLines, newLines } = reconstructSides(body);
+  const before = stripGeneratedLines(path, oldLines);
+  const after = stripGeneratedLines(path, newLines);
+  // Nothing generated on either side means this diff is not the solver's doing.
+  if (before.removed === 0 && after.removed === 0) return false;
+  // Trailing blank lines are what the append path leaves behind; they are not a
+  // change anyone made.
+  return before.kept.join('\n').trimEnd() === after.kept.join('\n').trimEnd();
+};
+
 /**
  * Measure a unified diff in a single pass.
  *
@@ -96,8 +216,7 @@ const measureDiff = diff => {
 
   const closeSection = () => {
     if (!section) return;
-    const isPlaceholder = Boolean(section.patterns) && section.patterns.every(pattern => pattern.test(section.body));
-    if (isPlaceholder) placeholderSections += 1;
+    if (isPlaceholderSection(section.path, section.body)) placeholderSections += 1;
     else {
       filesChanged += 1;
       additions += section.additions;
@@ -116,14 +235,13 @@ const measureDiff = diff => {
       closeSection();
       const match = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
       const path = match ? match[2] : '';
-      const patterns = PLACEHOLDER_CONTENT_PATTERNS.get(path) || null;
-      section = { patterns, body: '', additions: 0, deletions: 0 };
+      section = { path, candidate: PLACEHOLDER_GENERATED_LINES.has(path), body: '', additions: 0, deletions: 0 };
       continue;
     }
     if (!section) continue;
     // Only a placeholder candidate needs its text kept; every other file is
     // reduced to two counters as it streams past.
-    if (section.patterns) section.body += `${line}\n`;
+    if (section.candidate) section.body += `${line}\n`;
     if (line.length > 1) {
       if (line[0] === '+' && line[1] !== '+') section.additions += 1;
       else if (line[0] === '-' && line[1] !== '-') section.deletions += 1;
@@ -147,7 +265,7 @@ const measureDiff = diff => {
  * @param {number} params.prNumber
  * @param {Function} params.$ command-stream tagged-template executor
  * @param {Function} [params.log] - optional logger for the size diagnostic
- * @returns {Promise<{hasChanges: boolean, filesChanged: number, additions: number, deletions: number, placeholderOnly: boolean, measured: boolean, diffBytes: number}>}
+ * @returns {Promise<{hasChanges: boolean, filesChanged: number, additions: number, deletions: number, placeholderOnly: boolean, placeholderSections: number, measured: boolean, diffBytes: number}>}
  *   The counts cover the AI's own work: the solver's placeholder file is
  *   excluded and reported through `placeholderOnly` instead. `measured` is
  *   false when the diff could not be fetched, in which case callers must not
@@ -187,6 +305,11 @@ export const getPullRequestChangeStats = async ({ owner, repo, prNumber, $, log
     additions,
     deletions,
     placeholderOnly: filesChanged === 0 && placeholderSections > 0,
+    // Issue #2211: a pull request that has real changes *and* still carries the
+    // solver's placeholder is not empty, but it must not be merged with the
+    // placeholder in it either. Reported separately so the merge watcher can
+    // clean it up before merging instead of shipping it to the default branch.
+    placeholderSections,
     measured,
     diffBytes,
   };
@@ -233,4 +356,10 @@ export const EMPTY_PULL_REQUEST_BLOCKER = 'The pull request contains no changes
  */
 export const buildEmptyPullRequestBlocker = (stats = null) => (stats?.placeholderOnly ? 'The pull request contains only the placeholder file the solver commits to open a pull request, so there is nothing to merge' : EMPTY_PULL_REQUEST_BLOCKER);
 
-export default { getPullRequestChangeStats, formatChangeSummary, EMPTY_PULL_REQUEST_BLOCKER, buildEmptyPullRequestBlocker };
+/**
+ * Exported for tests and for `experiments/issue-2211`: measuring a diff without
+ * a GitHub round trip is the only way to replay an archived pull request.
+ */
+export const __measureDiffForTests = measureDiff;
+
+export default { getPullRequestChangeStats, formatChangeSummary, EMPTY_PULL_REQUEST_BLOCKER, buildEmptyPullRequestBlocker, __measureDiffForTests: measureDiff };

package/src/solve.auto-merge-guards.lib.mjs

@@ -150,3 +150,31 @@ export default {
   resolveDraftBlocker,
   resolveMergeFailure,
 };
+
+/**
+ * Issue #2211: revert a solver placeholder that survived into the pull request diff.
+ *
+ * `src/solve.mjs` reverts the placeholder before this loop starts, so reaching
+ * here means the session that created it crashed, was resumed from a different
+ * working directory, or was restarted inside the loop. Merging anyway publishes
+ * hive-mind's own scaffolding to the default branch, which is what happened to
+ * https://github.com/konard/audio-decomposer/pull/3 - and, eight times over, to
+ * the `.gitkeep` on the default branch of the template repository it was
+ * generated from. See docs/case-studies/issue-2211.
+ *
+ * Failure is not fatal: the caller re-measures the diff, and a placeholder that
+ * could not be reverted still keeps the pull request from looking mergeable.
+ *
+ * @returns {Promise<boolean>} whether a cleanup was attempted
+ */
+export const revertPlaceholderBeforeMerge = async ({ changeStats, tempDir, branchName, argv, log, formatAligned, cleanErrorMessage }) => {
+  if (!tempDir || !(changeStats?.placeholderSections > 0)) return false;
+  await log(formatAligned('🧹', 'Placeholder in diff:', 'reverting the solver placeholder file before it can be merged', 2), { level: 'warning' });
+  try {
+    const { cleanupClaudeFile } = await import('./solve.results.lib.mjs');
+    await cleanupClaudeFile(tempDir, branchName, null, argv);
+  } catch (error) {
+    await log(formatAligned('⚠️', 'Placeholder cleanup failed:', cleanErrorMessage(error), 2), { level: 'warning' });
+  }
+  return true;
+};

package/src/solve.auto-merge.lib.mjs

@@ -34,7 +34,7 @@ const { mergePullRequest, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDet
 // Issue #2182: guard rails for this loop (wall-clock ceiling, draft self-heal,
 // classified merge failures). See solve.auto-merge-guards.lib.mjs.
 const autoMergeGuards = await import('./solve.auto-merge-guards.lib.mjs');
-const { DRAFT_RECHECK_DELAY_MS, evaluateWatchTimeout, resolveDraftBlocker, resolveMergeFailure } = autoMergeGuards;
+const { DRAFT_RECHECK_DELAY_MS, evaluateWatchTimeout, resolveDraftBlocker, resolveMergeFailure, revertPlaceholderBeforeMerge } = autoMergeGuards;
 // Re-exported so callers and tests keep a single entry point for the watch loop.
 export const { DEFAULT_WATCH_TIMEOUT_HOURS, normalizeWatchTimeoutHours } = autoMergeGuards;
 // Import GitHub functions for log attachment
@@ -131,6 +131,8 @@ export const watchUntilMergeable = async params => {
   // Issue #1503: Track consecutive "no workflow runs" checks per-SHA (reset on new push)
   let consecutiveNoRunsChecks = 0;
   let lastKnownHeadSha = null;
+  // Issue #2211: revert a leftover solver placeholder at most once per watch.
+  let placeholderCleanupAttempted = false;
   // Issue #1567: Initial cooldown to let CI register and solution logs post
   const INITIAL_COOLDOWN_SECONDS = MIN_CI_CHECK_INTERVAL_SECONDS;
   // Issue #2182: this loop used to be `while (true)` with no wall-clock ceiling
@@ -330,6 +332,16 @@ export const watchUntilMergeable = async params => {
       if (isEmptyPullRequest) {
         await log(formatAligned('⚠️', 'PR is empty:', changeStats.placeholderOnly ? 'only the solver placeholder file is in the diff - not treating it as mergeable' : 'net diff contains no files - not treating it as mergeable', 2), { level: 'warning' });
       }
+      // Issue #2211: defense in depth - never merge the solver's own placeholder.
+      if (changeStats.placeholderSections > 0 && !placeholderCleanupAttempted) {
+        placeholderCleanupAttempted = true;
+        if (await revertPlaceholderBeforeMerge({ changeStats, tempDir, branchName: prBranch || branchName, argv, log, formatAligned, cleanErrorMessage })) {
+          // Give the revert push a moment to register, then re-measure so the
+          // merge decision is made on the post-cleanup diff.
+          await interruptibleSleep(DRAFT_RECHECK_DELAY_MS);
+          continue;
+        }
+      }
       // If PR is mergeable, no blockers, no new comments, no issue metadata
       // edits, no uncommitted changes and it actually changes something
       if (blockers.length === 0 && !hasNewComments && !hasIssueMetadataChanges && !hasUncommittedChanges && !isEmptyPullRequest) {

package/src/solve.config.lib.mjs

@@ -696,6 +696,12 @@ export const SOLVE_OPTION_DEFINITIONS = {
     alias: ['keep-going-until-all-requirements-are-fully-done', 'keep-working', 'keep-going'],
     default: undefined,
   },
+  'ensure-all-sub-issues-addressed': {
+    type: 'string',
+    description: '[EXPERIMENTAL] After the main solve completes, check that the pull request description closes every GitHub native sub-issue of the issue being solved with a reference GitHub actually recognizes. When references are missing, automatically restart the AI tool and ask it to double check that each of those sub-issues was really addressed in this single pull request. Accepts a number of restarts (default: 5), or "forever"/"unlimited" to remove the limit. Bare flag means the default of 5. Enabled automatically when solving a repository URL.',
+    alias: ['ensure-all-sub-issues', 'ensure-sub-issues'],
+    default: undefined,
+  },
   escalate: {
     type: 'string',
     description: '[EXPERIMENTAL] Start solving with a cheaper/lower-tier model and automatically escalate to a more capable (more expensive) model while unfinished work remains. Accepts a model range "<lower>-<upper>" using short Claude tier names (ladder: haiku < sonnet < opus < fable), e.g. "sonnet-opus". A single name (e.g. "opus") means just that tier. Bare flag means "sonnet-fable". The idea: iterate cheaply first so expensive models do more reading and less writing.',
@@ -1059,6 +1065,26 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     }
   }
 
+  // --ensure-all-sub-issues-addressed normalization (issue #2212)
+  // Same value semantics as --keep-working-until-all-requirements-are-fully-done:
+  // a number of restarts, the keywords "forever"/"unlimited"/"infinite", or no
+  // value (bare flag => default of 5). Final numeric normalization happens at
+  // runtime in solve.ensure-sub-issues.detect.lib.mjs.
+  {
+    const ensureSubIssuesAliases = ['--ensure-all-sub-issues-addressed', '--ensure-all-sub-issues', '--ensure-sub-issues'];
+    const ensureSubIssuesProvided = ensureSubIssuesAliases.some(alias => hasRawOption(rawArgs, alias));
+    if (ensureSubIssuesProvided) {
+      const current = argv.ensureAllSubIssuesAddressed;
+      if (current === true || current === '' || current === undefined || current === null) {
+        argv.ensureAllSubIssuesAddressed = 5;
+      } else if (typeof current === 'string') {
+        argv.ensureAllSubIssuesAddressed = current.trim();
+      }
+    } else if (argv.ensureAllSubIssuesAddressed === undefined) {
+      argv.ensureAllSubIssuesAddressed = undefined;
+    }
+  }
+
   // --escalate / --escalate-from / --escalate-steps normalization (issue #1885)
   // The bare `--escalate` flag is a string-typed option, so yargs yields `true`
   // (or an empty string) for a value-less flag. Canonicalize that to the default

package/src/solve.ensure-sub-issues.detect.lib.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+/**
+ * Pure detection helpers for `--ensure-all-sub-issues-addressed` (issue #2212).
+ *
+ * The option checks that the pull request description closes every sub-issue of
+ * the issue being solved with a reference GitHub actually recognizes. When a
+ * reference is missing, solve auto-restarts the AI tool and asks it to double
+ * check that every sub-issue was really addressed in this single pull request.
+ *
+ * GitHub requires the full closing syntax per issue — `Fixes #1, #2` closes only
+ * `#1` — which is exactly what `prClosesIssue` implements, so this module reuses
+ * it instead of writing a second, subtly different parser.
+ *
+ * Everything here is network-free so it can be unit tested in isolation. The
+ * network side lives in `solve.ensure-sub-issues.lib.mjs`.
+ */
+
+import { prClosesIssue } from './github-linking.lib.mjs';
+import { normalizeKeepWorkingLimit } from './solve.keep-working.detect.lib.mjs';
+
+/** Default number of auto-restarts when closing references are missing. */
+export const DEFAULT_ENSURE_SUB_ISSUES_LIMIT = 5;
+
+/**
+ * Reinforcement prompt appended to every restart, in addition to the concrete
+ * list of sub-issues whose closing references are missing.
+ */
+export const ENSURE_SUB_ISSUES_PROMPT = 'Double check that every sub-issue listed above was really addressed in this single pull request, then make sure the pull request description closes each of them with a GitHub recognized closing reference.';
+
+/**
+ * Normalize the `--ensure-all-sub-issues-addressed` value into a restart limit.
+ *
+ * Shares the semantics of `--keep-working-until-all-requirements-are-fully-done`:
+ *  - falsy (undefined / null / false / "") -> 0 (disabled)
+ *  - bare flag (true) -> DEFAULT_ENSURE_SUB_ISSUES_LIMIT
+ *  - "forever" / "unlimited" / "infinite" / 0 / "0" -> Infinity
+ *  - positive number / numeric string -> floor(value)
+ *
+ * @param {*} value
+ * @returns {number}
+ */
+export function normalizeEnsureSubIssuesLimit(value) {
+  return normalizeKeepWorkingLimit(value, DEFAULT_ENSURE_SUB_ISSUES_LIMIT);
+}
+
+/**
+ * Human readable description of the limit for logs.
+ * @param {number} limit
+ * @returns {string}
+ */
+export function formatEnsureSubIssuesLimit(limit) {
+  return limit === Infinity ? 'unlimited' : `${limit}`;
+}
+
+/**
+ * Normalize a raw sub-issue entry (REST `sub_issues` payload, or an already
+ * normalized entry) into `{number, title, owner, repo, url}`.
+ *
+ * The owner/repo are derived from `repository_url` when present so cross
+ * repository sub-issues are matched with their fully qualified reference.
+ *
+ * @param {object} entry
+ * @param {{owner?: string, repo?: string}} [fallbackRepository]
+ * @returns {{number: number, title: string, owner: string|null, repo: string|null, url: string}|null}
+ */
+export function normalizeSubIssueEntry(entry, fallbackRepository = {}) {
+  if (!entry || typeof entry !== 'object') return null;
+  const number = Number(entry.number);
+  if (!Number.isInteger(number) || number <= 0) return null;
+
+  let owner = entry.owner || fallbackRepository.owner || null;
+  let repo = entry.repo || fallbackRepository.repo || null;
+
+  const repositoryUrl = String(entry.repository_url || '');
+  const match = repositoryUrl.match(/repos\/([^/]+)\/([^/]+)$/);
+  if (match) {
+    owner = match[1];
+    repo = match[2];
+  }
+
+  return {
+    number,
+    title: String(entry.title || '').trim(),
+    owner,
+    repo,
+    url: String(entry.html_url || entry.url || '').trim(),
+  };
+}
+
+/**
+ * Find the sub-issues whose closing reference is missing from `text`.
+ *
+ * A sub-issue counts as referenced when the text contains a GitHub recognized
+ * closing keyword for it (`closes #12`, `fixes owner/repo#12`,
+ * `resolves https://github.com/owner/repo/issues/12`, ...).
+ *
+ * @param {object} params
+ * @param {string} params.text - pull request description (and optionally title)
+ * @param {Array<object>} params.subIssues
+ * @param {string} [params.owner] - repository of the parent issue
+ * @param {string} [params.repo]
+ * @returns {{missing: Array<object>, referenced: Array<object>, total: number}}
+ */
+export function findMissingSubIssueReferences({ text, subIssues, owner = null, repo = null }) {
+  const normalized = (Array.isArray(subIssues) ? subIssues : []).map(entry => normalizeSubIssueEntry(entry, { owner, repo })).filter(Boolean);
+
+  const missing = [];
+  const referenced = [];
+
+  for (const subIssue of normalized) {
+    if (prClosesIssue(text, subIssue.number, subIssue.owner, subIssue.repo)) {
+      referenced.push(subIssue);
+    } else {
+      missing.push(subIssue);
+    }
+  }
+
+  return { missing, referenced, total: normalized.length };
+}
+
+function formatSubIssueReference(subIssue, owner, repo) {
+  const crossRepository = subIssue.owner && subIssue.repo && (subIssue.owner !== owner || subIssue.repo !== repo);
+  return crossRepository ? `${subIssue.owner}/${subIssue.repo}#${subIssue.number}` : `#${subIssue.number}`;
+}
+
+/**
+ * Build the closing-reference block the AI is asked to add, one keyword per
+ * issue as GitHub requires.
+ *
+ * @param {Array<object>} subIssues
+ * @param {object} [params]
+ * @returns {string}
+ */
+export function buildMissingReferenceBlock(subIssues, { owner = null, repo = null, keyword = 'Fixes' } = {}) {
+  return (Array.isArray(subIssues) ? subIssues : []).map(subIssue => `${keyword} ${formatSubIssueReference(subIssue, owner, repo)}`).join('\n');
+}
+
+/**
+ * Build the feedback lines injected into the restart iteration.
+ *
+ * @param {object} params
+ * @param {Array<object>} params.missing
+ * @param {number} params.total
+ * @param {number} params.iteration
+ * @param {number} params.limit
+ * @param {string} [params.owner]
+ * @param {string} [params.repo]
+ * @param {string|number} [params.issueNumber] - parent issue
+ * @returns {string[]}
+ */
+export function buildEnsureSubIssuesFeedback({ missing, total, iteration, limit, owner = null, repo = null, issueNumber = null }) {
+  const missingList = Array.isArray(missing) ? missing : [];
+  const lines = ['', '='.repeat(60), '🧩 ENSURE ALL SUB-ISSUES ADDRESSED:', '='.repeat(60), '', `Restart ${iteration}/${formatEnsureSubIssuesLimit(limit)}.`, '', `This issue${issueNumber ? ` (#${issueNumber})` : ''} has ${total} sub-issue(s). The pull request description is missing a GitHub recognized closing reference for ${missingList.length} of them:`, ''];
+
+  for (const subIssue of missingList) {
+    const reference = formatSubIssueReference(subIssue, owner, repo);
+    lines.push(`  • ${reference}${subIssue.title ? ` — ${subIssue.title}` : ''}${subIssue.url ? ` (${subIssue.url})` : ''}`);
+  }
+
+  lines.push('', 'For each sub-issue above:', '  1. Verify it was really addressed by the changes in this pull request. If it was not, implement it now — in this same pull request.', '  2. Then update the pull request description so it closes the sub-issue.', '', 'GitHub only recognizes the full closing syntax repeated per issue: "Fixes #1, #2" closes only #1.', 'Add these lines to the pull request description (keep any existing closing references):', '', buildMissingReferenceBlock(missingList, { owner, repo }), '', ENSURE_SUB_ISSUES_PROMPT, '');
+
+  return lines;
+}
+
+export default {
+  DEFAULT_ENSURE_SUB_ISSUES_LIMIT,
+  ENSURE_SUB_ISSUES_PROMPT,
+  normalizeEnsureSubIssuesLimit,
+  formatEnsureSubIssuesLimit,
+  normalizeSubIssueEntry,
+  findMissingSubIssueReferences,
+  buildMissingReferenceBlock,
+  buildEnsureSubIssuesFeedback,
+};