@link-assistant/hive-mind 2.19.2 → 2.20.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @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

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.2",
+  "version": "2.20.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

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,
+};

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

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+import { QUIET_PROBE } from './quiet-probe.lib.mjs';
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+
+/**
+ * `--ensure-all-sub-issues-addressed` restart loop for solve.mjs (issue #2212).
+ *
+ * After the main solve completes, this module lists the GitHub native
+ * sub-issues of the issue being solved and checks that the pull request
+ * description closes every one of them with a reference GitHub actually
+ * recognizes. When references are missing it restarts the AI tool, asking it to
+ * double check that each of those sub-issues was really addressed in this single
+ * pull request and to add the missing closing references. It keeps restarting
+ * until nothing is missing or the configured restart limit is reached.
+ *
+ * This is what makes `/solve <repository-url>` safe: the combined issue's
+ * sub-issues are exactly the repository's open issues, so the check guarantees
+ * the single pull request lists all of them and closes them on merge.
+ *
+ * The pure detection helpers live in `solve.ensure-sub-issues.detect.lib.mjs`.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2212
+ */
+
+// Check if use is already defined globally (when imported from solve.mjs)
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  await ensureUseM();
+}
+const use = globalThis.use;
+
+// Use command-stream for consistent $ behavior across runtimes
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
+
+const lib = await import('./lib.mjs');
+const { log, cleanErrorMessage } = lib;
+
+const restartShared = await import('./solve.restart-shared.lib.mjs');
+const { executeToolIteration, isApiError, isUsageLimitReached } = restartShared;
+
+const sentryLib = await import('./sentry.lib.mjs');
+const { reportError } = sentryLib;
+
+const detectLib = await import('./solve.ensure-sub-issues.detect.lib.mjs');
+const { DEFAULT_ENSURE_SUB_ISSUES_LIMIT, ENSURE_SUB_ISSUES_PROMPT, buildEnsureSubIssuesFeedback, buildMissingReferenceBlock, findMissingSubIssueReferences, formatEnsureSubIssuesLimit, normalizeEnsureSubIssuesLimit, normalizeSubIssueEntry } = detectLib;
+
+// Re-export the pure helpers so importers only need this module.
+export { DEFAULT_ENSURE_SUB_ISSUES_LIMIT, ENSURE_SUB_ISSUES_PROMPT, buildEnsureSubIssuesFeedback, buildMissingReferenceBlock, findMissingSubIssueReferences, formatEnsureSubIssuesLimit, normalizeEnsureSubIssuesLimit, normalizeSubIssueEntry };
+
+/**
+ * Hard cap on consecutive AI errors, so "unlimited" cannot spin forever.
+ * Mirrors the keep-working loop (issue #1883).
+ */
+const MAX_CONSECUTIVE_ERRORS = 3;
+
+/**
+ * List the GitHub native sub-issues of an issue.
+ *
+ * `--paginate` is required: the endpoint returns 30 entries per page by default
+ * and a parent may have up to 100 sub-issues.
+ *
+ * @param {object} params
+ * @returns {Promise<Array<object>>}
+ */
+export const fetchSubIssues = async ({ owner, repo, issueNumber }) => {
+  // Issue #2135: `mirror: false` — the payload is inspected here, not shown.
+  const result = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/issues/${issueNumber}/sub_issues --paginate`;
+  if (result.code !== 0) {
+    const output = (result.stderr || result.stdout || '').toString().trim();
+    throw new Error(output || `gh api sub_issues exited with code ${result.code}`);
+  }
+  const parsed = JSON.parse(result.stdout.toString() || '[]');
+  return Array.isArray(parsed) ? parsed : [];
+};
+
+/**
+ * Fetch the pull request description (and title, so a closing reference placed
+ * in the title is honored too).
+ *
+ * @param {object} params
+ * @returns {Promise<string>}
+ */
+export const fetchPullRequestText = async ({ owner, repo, prNumber }) => {
+  // Issue #2135: `mirror: false` — the body can be very large.
+  const result = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/pulls/${prNumber}`;
+  if (result.code !== 0) {
+    const output = (result.stderr || result.stdout || '').toString().trim();
+    throw new Error(output || `gh api pulls exited with code ${result.code}`);
+  }
+  const pr = JSON.parse(result.stdout.toString() || '{}');
+  // The title is included on purpose: a closing reference is recognized by
+  // GitHub in the pull request title as well as in its description.
+  return [pr.title || '', pr.body || ''].join('\n\n');
+};
+
+/**
+ * Runs the `--ensure-all-sub-issues-addressed` restart iterations.
+ *
+ * @param {object} params
+ * @param {string} params.issueUrl
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {string|number} params.issueNumber
+ * @param {string|number} params.prNumber
+ * @param {string} params.branchName
+ * @param {string} params.tempDir
+ * @param {string} [params.workspaceTmpDir]
+ * @param {object} params.argv
+ * @param {function} params.cleanupClaudeFile
+ * @returns {Promise<{sessionId, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo}|null>}
+ */
+export const runEnsureAllSubIssuesAddressed = async ({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, workspaceTmpDir, argv, cleanupClaudeFile }) => {
+  const limit = normalizeEnsureSubIssuesLimit(argv.ensureAllSubIssuesAddressed ?? argv['ensure-all-sub-issues-addressed']);
+  if (!limit || !prNumber || !issueNumber) {
+    return null;
+  }
+
+  await log('');
+  await log(`🧩 ENSURE-SUB-ISSUES: Verifying the pull request description closes every sub-issue of #${issueNumber} (limit: ${formatEnsureSubIssuesLimit(limit)} restart(s))`);
+
+  let subIssues;
+  try {
+    subIssues = await fetchSubIssues({ owner, repo, issueNumber });
+  } catch (error) {
+    reportError(error, { context: 'ensure_sub_issues_fetch', owner, repo, issueNumber, operation: 'fetch_sub_issues' });
+    await log(`⚠️  ENSURE-SUB-ISSUES: Could not list sub-issues: ${cleanErrorMessage(error)}`, { level: 'warning' });
+    return null;
+  }
+
+  if (subIssues.length === 0) {
+    await log(`✅ ENSURE-SUB-ISSUES: Issue #${issueNumber} has no sub-issues. Nothing to verify.`);
+    return null;
+  }
+
+  await log(`   Sub-issues to verify: ${subIssues.length}`);
+
+  // Merge state is only used to enrich the restart prompt; a failure here is
+  // never a reason to skip the check.
+  let currentMergeStateStatus = null;
+  try {
+    const prStateResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.mergeStateStatus'`;
+    if (prStateResult.code === 0) {
+      currentMergeStateStatus = prStateResult.stdout.toString().trim();
+    }
+  } catch {
+    // Ignore errors getting merge state
+  }
+
+  let sessionId;
+  let anthropicTotalCostUSD;
+  let publicPricingEstimate;
+  let pricingInfo;
+  let consecutiveErrors = 0;
+  let iteration = 0;
+
+  while (true) {
+    let prText;
+    try {
+      prText = await fetchPullRequestText({ owner, repo, prNumber });
+    } catch (error) {
+      reportError(error, { context: 'ensure_sub_issues_fetch_pr', owner, repo, prNumber, operation: 'fetch_pr_body' });
+      await log(`⚠️  ENSURE-SUB-ISSUES: Could not read the pull request description: ${cleanErrorMessage(error)}`, { level: 'warning' });
+      break;
+    }
+
+    const { missing, total } = findMissingSubIssueReferences({ text: prText, subIssues, owner, repo });
+
+    if (missing.length === 0) {
+      if (iteration === 0) {
+        await log(`✅ ENSURE-SUB-ISSUES: All ${total} sub-issue(s) are closed by the pull request description.`);
+      } else {
+        await log(`✅ ENSURE-SUB-ISSUES: All ${total} sub-issue(s) are closed by the pull request description after ${iteration} restart(s).`);
+      }
+      break;
+    }
+
+    if (iteration >= limit) {
+      await log(`🛑 ENSURE-SUB-ISSUES: Reached the restart limit (${formatEnsureSubIssuesLimit(limit)}) with ${missing.length}/${total} sub-issue(s) still missing a closing reference.`);
+      for (const subIssue of missing.slice(0, 20)) {
+        await log(`   • #${subIssue.number}${subIssue.title ? ` — ${subIssue.title}` : ''}`);
+      }
+      await log('   Add these lines to the pull request description to close them on merge:');
+      await log(buildMissingReferenceBlock(missing, { owner, repo }));
+      break;
+    }
+
+    iteration++;
+    await log('');
+    await log(`🔁 ENSURE-SUB-ISSUES iteration ${iteration}/${formatEnsureSubIssuesLimit(limit)}: ${missing.length}/${total} sub-issue(s) missing a closing reference, restarting...`);
+    for (const subIssue of missing.slice(0, 20)) {
+      await log(`   • #${subIssue.number}${subIssue.title ? ` — ${subIssue.title}` : ''}`);
+    }
+
+    // Issue #1572 pattern: sync the local branch with remote before restarting.
+    try {
+      const pullResult = await $({ cwd: tempDir })`git pull origin ${branchName} 2>&1`;
+      if (pullResult.code === 0) {
+        await log(`   Synced local branch ${branchName} from remote`, { verbose: true });
+      } else {
+        await log(`   Warning: git pull failed (code ${pullResult.code}); continuing with local state`, { level: 'warning' });
+      }
+    } catch (error) {
+      reportError(error, { context: 'ensure_sub_issues_git_pull', branchName, operation: 'git_pull' });
+      await log(`   Warning: git pull error: ${cleanErrorMessage(error)}`, { level: 'warning' });
+    }
+
+    const feedbackLines = buildEnsureSubIssuesFeedback({ missing, total, iteration, limit, owner, repo, issueNumber });
+
+    const iterationResult = await executeToolIteration({
+      issueUrl,
+      owner,
+      repo,
+      issueNumber,
+      prNumber,
+      branchName,
+      tempDir,
+      workspaceTmpDir,
+      mergeStateStatus: currentMergeStateStatus,
+      feedbackLines,
+      argv: {
+        ...argv,
+        promptEnsureAllRequirementsAreMet: true,
+        // Prevent recursion inside the restart iteration.
+        ensureAllSubIssuesAddressed: 0,
+        'ensure-all-sub-issues-addressed': 0,
+      },
+    });
+
+    if (iterationResult) {
+      if (iterationResult.sessionId) sessionId = iterationResult.sessionId;
+      if (iterationResult.anthropicTotalCostUSD) anthropicTotalCostUSD = iterationResult.anthropicTotalCostUSD;
+      if (iterationResult.publicPricingEstimate) publicPricingEstimate = iterationResult.publicPricingEstimate;
+      if (iterationResult.pricingInfo) pricingInfo = iterationResult.pricingInfo;
+    }
+
+    if (isUsageLimitReached(iterationResult)) {
+      await log('🛑 ENSURE-SUB-ISSUES: Usage limit reached during restart. Stopping.');
+      break;
+    }
+    if (isApiError(iterationResult)) {
+      consecutiveErrors++;
+      await log(`⚠️  ENSURE-SUB-ISSUES: API error during restart (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS} consecutive).`, { level: 'warning' });
+      if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+        await log('🛑 ENSURE-SUB-ISSUES: Too many consecutive errors. Stopping.');
+        break;
+      }
+    } else {
+      consecutiveErrors = 0;
+    }
+
+    await log(`✅ ENSURE-SUB-ISSUES iteration ${iteration}/${formatEnsureSubIssuesLimit(limit)} complete`);
+    await log('');
+  }
+
+  try {
+    await cleanupClaudeFile?.(tempDir, branchName, null, argv);
+  } catch (error) {
+    reportError(error, { context: 'ensure_sub_issues_cleanup', branchName, operation: 'cleanup_claude_file' });
+  }
+
+  if (iteration === 0) return null;
+  return { sessionId, anthropicTotalCostUSD, publicPricingEstimate, pricingInfo };
+};
+
+export default {
+  DEFAULT_ENSURE_SUB_ISSUES_LIMIT,
+  ENSURE_SUB_ISSUES_PROMPT,
+  fetchSubIssues,
+  fetchPullRequestText,
+  findMissingSubIssueReferences,
+  normalizeEnsureSubIssuesLimit,
+  formatEnsureSubIssuesLimit,
+  runEnsureAllSubIssuesAddressed,
+};

package/src/solve.mjs

@@ -47,6 +47,7 @@ const { startAutoRestartUntilMergeable } = await import('./solve.auto-merge.lib.
 const { runAutoEnsureRequirements } = await import('./solve.auto-ensure.lib.mjs');
 const { runKeepWorkingUntilDone } = await import('./solve.keep-working.lib.mjs');
 const { runEscalation } = await import('./solve.escalate.lib.mjs');
+const { runEnsureAllSubIssuesAddressed } = await import('./solve.ensure-sub-issues.lib.mjs');
 const { finalizeSolveProcess } = await import('./solve.finalize.lib.mjs');
 const exitHandler = await import('./exit-handler.lib.mjs');
 const { initializeExitHandler, installGlobalExitHandlers, safeExit: baseSafeExit, logActiveHandles } = exitHandler;
@@ -152,6 +153,25 @@ if (!issueUrl) {
   await log('Run "solve.mjs --help" for more information', { level: 'error' });
   await safeExit(1, 'Missing required GitHub URL');
 }
+// Issue #2212: repository mode. When a repository URL is given instead of an
+// issue/pull request URL, collect every open issue of that repository, create a
+// single combined issue that lists them as GitHub native sub-issues, and solve
+// that issue instead — so one pull request can close all of them at once.
+{
+  const { resolveRepositoryModeTarget } = await import('./solve.repository-mode.run.lib.mjs');
+  const repositoryMode = await resolveRepositoryModeTarget({ url: issueUrl, log });
+  if (repositoryMode.handled) {
+    if (repositoryMode.error) {
+      await log(`Error: ${repositoryMode.error}`, { level: 'error' });
+      await safeExit(1, 'Repository mode failed');
+    }
+    issueUrl = repositoryMode.issueUrl;
+    argv['issue-url'] = repositoryMode.issueUrl;
+    // Repository mode always asks for deep analysis and always double checks
+    // that the pull request lists every issue it is supposed to close.
+    Object.assign(argv, repositoryMode.argvOverrides);
+  }
+}
 // Validate GitHub URL using validation module (more thorough check)
 const urlValidation = validateGitHubUrl(issueUrl);
 if (!urlValidation.isValid) {
@@ -1081,6 +1101,10 @@ try {
   applyRestartResult(await runEscalation({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, workspaceTmpDir, argv, cleanupClaudeFile, resultSummary }));
   applyRestartResult(await runAutoEnsureRequirements({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, argv, cleanupClaudeFile }));
   applyRestartResult(await runKeepWorkingUntilDone({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, workspaceTmpDir, argv, cleanupClaudeFile, resultSummary }));
+  // Issue #2212: runs last on purpose — the earlier loops may still rewrite the
+  // pull request description, so the closing references are verified against its
+  // final state.
+  applyRestartResult(await runEnsureAllSubIssuesAddressed({ issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, workspaceTmpDir, argv, cleanupClaudeFile }));
   // Start watch mode if enabled OR if we need to handle uncommitted changes
   if (argv.verbose) {
     await log('');

package/src/solve.repository-mode.lib.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+/**
+ * Pure helpers for `/solve <github-repository-url>` — "repository mode"
+ * (issue #2212).
+ *
+ * When `/solve` is given a repository URL instead of an issue or pull request
+ * URL, it behaves similarly to `/fix --ci-cd`: it collects data about the
+ * repository, creates a single combined issue that lists every open issue in
+ * the repository as a GitHub native sub-issue, and then solves that combined
+ * issue as it normally would — producing one pull request that closes all of
+ * them at once.
+ *
+ * GitHub allows at most 100 sub-issues per parent issue
+ * (https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/adding-sub-issues),
+ * so when a repository has more open issues only the oldest 100 are attached
+ * and the rest are intentionally left out of this run.
+ *
+ * Everything in this module is network- and filesystem-free so it can be unit
+ * tested without GitHub access. The network side lives in
+ * `solve.repository-mode.run.lib.mjs`.
+ */
+
+/**
+ * GitHub's documented maximum number of sub-issues per parent issue.
+ * @see https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/adding-sub-issues
+ */
+export const MAX_SUB_ISSUES_PER_PARENT = 100;
+
+/** Marker that identifies an issue generated by `/solve <repository-url>`. */
+export const REPOSITORY_MODE_MARKER = '<!-- hive-mind-solve-repository-mode -->';
+
+/**
+ * Build the `gh api` arguments that list every open issue of a repository,
+ * oldest first.
+ *
+ * The REST `/issues` endpoint also returns pull requests; they are filtered out
+ * by {@link isPullRequestEntry}. `--paginate` is required because the endpoint
+ * returns at most 100 entries per page.
+ *
+ * @param {object} params
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {number} [params.perPage=100]
+ * @returns {string[]} argument list for `gh`
+ */
+export function buildOpenIssuesApiArgs({ owner, repo, perPage = MAX_SUB_ISSUES_PER_PARENT }) {
+  if (!owner || !repo) throw new Error('buildOpenIssuesApiArgs requires owner and repo');
+  const size = Number(perPage);
+  const safePerPage = Number.isInteger(size) && size >= 1 && size <= 100 ? size : MAX_SUB_ISSUES_PER_PARENT;
+  // Query parameters must be part of the endpoint string: `gh api -f key=value`
+  // switches the request to POST, which makes this endpoint fail with
+  // HTTP 422 ("title wasn't supplied").
+  return ['api', `repos/${owner}/${repo}/issues?state=open&sort=created&direction=asc&per_page=${safePerPage}`, '--paginate'];
+}
+
+/**
+ * The REST issues endpoint returns pull requests alongside issues; a pull
+ * request is identified by the presence of a `pull_request` object.
+ *
+ * @param {object} entry - raw REST issue entry
+ * @returns {boolean}
+ */
+export function isPullRequestEntry(entry) {
+  return Boolean(entry && typeof entry === 'object' && entry.pull_request);
+}
+
+/**
+ * Normalize a raw REST issue entry into the minimal shape the rest of
+ * repository mode needs.
+ *
+ * `id` is the REST database id (not the GraphQL node id): the sub-issues API
+ * takes `sub_issue_id` as a REST id.
+ *
+ * @param {object} entry
+ * @returns {{number: number, id: number, title: string, url: string, createdAt: string}|null}
+ */
+export function normalizeOpenIssueEntry(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const number = Number(entry.number);
+  const id = Number(entry.id);
+  if (!Number.isInteger(number) || number <= 0) return null;
+  return {
+    number,
+    id: Number.isInteger(id) && id > 0 ? id : null,
+    title: String(entry.title || '').trim(),
+    url: String(entry.html_url || '').trim(),
+    createdAt: String(entry.created_at || '').trim(),
+  };
+}
+
+/**
+ * Filter out pull requests, normalize, sort oldest-first and cap the list at
+ * `limit` entries.
+ *
+ * Sorting is done here (not only server-side) so the selection is deterministic
+ * even when the caller passes an unsorted list. Ties fall back to the issue
+ * number, which is monotonic per repository.
+ *
+ * @param {Array<object>} entries - raw REST issue entries
+ * @param {object} [options]
+ * @param {number} [options.limit=MAX_SUB_ISSUES_PER_PARENT]
+ * @param {Array<number>} [options.exclude] - issue numbers to skip
+ * @returns {{selected: Array<object>, totalOpen: number, skipped: number}}
+ */
+export function selectOldestOpenIssues(entries, { limit = MAX_SUB_ISSUES_PER_PARENT, exclude = [] } = {}) {
+  const excluded = new Set((exclude || []).map(Number).filter(Number.isInteger));
+  const issues = (Array.isArray(entries) ? entries : [])
+    .filter(entry => !isPullRequestEntry(entry))
+    .map(normalizeOpenIssueEntry)
+    .filter(Boolean)
+    .filter(issue => !excluded.has(issue.number));
+
+  issues.sort((a, b) => {
+    const aTime = Date.parse(a.createdAt);
+    const bTime = Date.parse(b.createdAt);
+    if (Number.isFinite(aTime) && Number.isFinite(bTime) && aTime !== bTime) return aTime - bTime;
+    return a.number - b.number;
+  });
+
+  const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : MAX_SUB_ISSUES_PER_PARENT;
+  const selected = issues.slice(0, cap);
+
+  return {
+    selected,
+    totalOpen: issues.length,
+    skipped: Math.max(0, issues.length - selected.length),
+  };
+}
+
+/**
+ * Title for the combined issue.
+ *
+ * @param {object} params
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {number} params.count - number of attached sub-issues
+ * @param {number} params.totalOpen - total open issues found in the repository
+ * @returns {string}
+ */
+export function buildCombinedIssueTitle({ owner, repo, count, totalOpen }) {
+  const repository = `${owner}/${repo}`;
+  if (totalOpen > count) {
+    return `Address the ${count} oldest open issues in ${repository} (of ${totalOpen} open)`;
+  }
+  if (count === 1) {
+    return `Address the single open issue in ${repository}`;
+  }
+  return `Address all ${count} open issues in ${repository}`;
+}
+
+function formatIssueLine(issue) {
+  const created = issue.createdAt ? ` — opened ${issue.createdAt.slice(0, 10)}` : '';
+  const title = issue.title ? ` ${issue.title}` : '';
+  return `- [ ] #${issue.number}${title}${created}`;
+}
+
+/**
+ * Build the closing-keyword block the pull request description must contain.
+ *
+ * GitHub requires the full syntax for *each* issue: a single keyword does not
+ * apply to a comma separated list of issues
+ * (https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/linking-a-pull-request-to-an-issue).
+ *
+ * @param {Array<{number: number}>} issues
+ * @param {string} [keyword='Fixes']
+ * @returns {string}
+ */
+export function buildClosingKeywordBlock(issues, keyword = 'Fixes') {
+  return (Array.isArray(issues) ? issues : []).map(issue => `${keyword} #${issue.number}`).join('\n');
+}
+
+/**
+ * Body of the combined issue.
+ *
+ * @param {object} params
+ * @param {{owner: string, repo: string, url: string}} params.repository
+ * @param {Array<object>} params.issues - selected sub-issues (oldest first)
+ * @param {number} params.totalOpen
+ * @param {number} [params.limit=MAX_SUB_ISSUES_PER_PARENT]
+ * @param {string} [params.sourceIssueUrl] - issue that introduced repository mode
+ * @returns {string}
+ */
+export function buildCombinedIssueBody({ repository, issues, totalOpen, limit = MAX_SUB_ISSUES_PER_PARENT, sourceIssueUrl = 'https://github.com/link-assistant/hive-mind/issues/2212' }) {
+  const list = Array.isArray(issues) ? issues : [];
+  const repositoryUrl = repository.url || `https://github.com/${repository.owner}/${repository.repo}`;
+  const skipped = Math.max(0, Number(totalOpen || 0) - list.length);
+
+  const lines = [REPOSITORY_MODE_MARKER, '', '## Objective', '', `Address every open issue listed below in [${repository.owner}/${repository.repo}](${repositoryUrl}) with a **single pull request**.`, '', `This issue was generated automatically by \`/solve ${repositoryUrl}\` (repository mode, see ${sourceIssueUrl}). Every issue below is attached to this issue as a GitHub native sub-issue.`, '', '## Scope', '', `- Open issues found in the repository: ${totalOpen}`, `- Issues attached as sub-issues of this issue: ${list.length}`, `- GitHub sub-issue limit per parent issue: ${limit}`];
+
+  if (skipped > 0) {
+    lines.push(`- Open issues intentionally left out of this run (newest ${skipped}, over the sub-issue limit): ${skipped}`);
+  }
+
+  lines.push('', '## Issues to address', '');
+
+  if (list.length === 0) {
+    lines.push('_No open issues were found._');
+  } else {
+    lines.push(...list.map(formatIssueLine));
+  }
+
+  lines.push('', '## Requirements', '', '1. Read every issue listed above (including its comments) and fully implement what it asks for.', '2. Do all of the work in this single pull request. Do not defer any listed issue to a follow-up pull request.', '3. The pull request description **must** close this issue and **every** issue listed above, so that merging the pull request closes all of them at once.', '4. GitHub requires the full closing syntax for each issue: one keyword per issue. `Fixes #1, #2` only closes `#1`. Use the block below verbatim (plus `Fixes #<this issue>` for this issue).', '5. If an issue turns out to be already resolved or not reproducible, say so explicitly in the pull request description — but still keep its closing reference so it is closed on merge.', '', '## Required closing references in the pull request description', '', '```', buildClosingKeywordBlock(list) || '(no issues)', '```', '');
+
+  return lines.join('\n');
+}
+
+/**
+ * Human-readable summary of what repository mode is about to do, for logs.
+ *
+ * @param {object} params
+ * @returns {string[]}
+ */
+export function buildRepositoryModeSummaryLines({ totalOpen, selectedCount, skipped, limit = MAX_SUB_ISSUES_PER_PARENT }) {
+  const lines = [`   Open issues found:        ${totalOpen}`, `   Attached as sub-issues:   ${selectedCount} (limit ${limit})`];
+  if (skipped > 0) {
+    lines.push(`   Left out (newest, over limit): ${skipped}`);
+  }
+  return lines;
+}
+
+export default {
+  MAX_SUB_ISSUES_PER_PARENT,
+  REPOSITORY_MODE_MARKER,
+  buildOpenIssuesApiArgs,
+  isPullRequestEntry,
+  normalizeOpenIssueEntry,
+  selectOldestOpenIssues,
+  buildCombinedIssueTitle,
+  buildClosingKeywordBlock,
+  buildCombinedIssueBody,
+  buildRepositoryModeSummaryLines,
+};

package/src/solve.repository-mode.run.lib.mjs

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub-backed orchestration for `/solve <github-repository-url>` — repository
+ * mode (issue #2212).
+ *
+ * Flow, mirroring how `/fix --ci-cd` turns a repository into a solvable issue:
+ *   1. list every open issue of the repository (oldest first, pull requests
+ *      excluded),
+ *   2. create one combined issue that lists them,
+ *   3. attach each of them as a GitHub native sub-issue of the combined issue
+ *      (at most 100 — GitHub's per-parent limit),
+ *   4. hand the combined issue back to `/solve`, which then runs its normal
+ *      single-issue flow with `--deep-analysis` and
+ *      `--ensure-all-sub-issues-addressed` enabled.
+ *
+ * The pure helpers live in `solve.repository-mode.lib.mjs`.
+ */
+
+import { spawn } from 'child_process';
+import { describeChildExit } from './child-exit.lib.mjs';
+import { parseGitHubUrl } from './github-url-parser.lib.mjs';
+import { createTaskIssue } from './task.issue-creation.lib.mjs';
+import { buildAddSubIssueApiArgs } from './task.split.lib.mjs';
+import { MAX_SUB_ISSUES_PER_PARENT, buildCombinedIssueBody, buildCombinedIssueTitle, buildOpenIssuesApiArgs, buildRepositoryModeSummaryLines, selectOldestOpenIssues } from './solve.repository-mode.lib.mjs';
+import { isRateLimitError } from './github-rate-limit.lib.mjs';
+
+/** Labels applied best-effort to the generated combined issue. */
+export const REPOSITORY_MODE_ISSUE_LABELS = Object.freeze(['enhancement']);
+
+/**
+ * Pause between two sub-issue POSTs.
+ *
+ * GitHub's own documentation warns that "creating content too quickly using
+ * this endpoint may result in secondary rate limiting"
+ * (https://docs.github.com/en/rest/issues/sub-issues), and its best-practice
+ * guide asks for at least one second between mutative requests. Attaching 100
+ * sub-issues therefore costs about a minute — negligible next to a solve run,
+ * and much cheaper than being throttled halfway through.
+ */
+export const SUB_ISSUE_ATTACH_DELAY_MS = 1000;
+
+/** Attempts per sub-issue when GitHub answers with a rate-limit error. */
+export const SUB_ISSUE_ATTACH_MAX_ATTEMPTS = 3;
+
+/**
+ * Backoff before retrying a rate-limited sub-issue attachment.
+ *
+ * GitHub's best-practice guide asks to "wait for at least one minute before
+ * retrying" a secondary rate-limit error, then "an exponentially increasing
+ * amount of time between retries"
+ * (https://docs.github.com/en/rest/using-the-rest-api/best-practices-for-using-the-rest-api#handle-rate-limit-errors-appropriately).
+ */
+export const SUB_ISSUE_ATTACH_BACKOFF_MS = Object.freeze([60000, 120000]);
+
+const defaultSleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+function runCommand(command, args, options = {}) {
+  return new Promise(resolve => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+      ...options,
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', data => {
+      stdout += data.toString();
+    });
+    child.stderr.on('data', data => {
+      stderr += data.toString();
+    });
+    child.on('error', error => {
+      resolve({ code: 1, stdout, stderr: stderr || error.message });
+    });
+    child.on('close', (code, signal) => {
+      resolve({ code, stdout, stderr, signal });
+    });
+  });
+}
+
+async function commandOutput(run, command, args) {
+  const result = await run(command, args);
+  if (result.code !== 0) {
+    const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
+    // Issue #2135: `describeChildExit` names a signal instead of "code null".
+    throw new Error(output || describeChildExit({ command, code: result.code, signal: result.signal }));
+  }
+  return result.stdout.trim();
+}
+
+/**
+ * Parse a repository URL into the `{owner, repo, fullName, url}` shape the rest
+ * of this module (and `createTaskIssue`) expects.
+ *
+ * @param {string} url
+ * @returns {{owner: string, repo: string, fullName: string, url: string}|null}
+ */
+export function parseRepositoryModeUrl(url) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed.valid || parsed.type !== 'repo') return null;
+  return {
+    owner: parsed.owner,
+    repo: parsed.repo,
+    fullName: `${parsed.owner}/${parsed.repo}`,
+    url: parsed.normalized || `https://github.com/${parsed.owner}/${parsed.repo}`,
+  };
+}
+
+/**
+ * Fetch every open issue of a repository (pull requests included — the caller
+ * filters them out via `selectOldestOpenIssues`).
+ *
+ * @param {object} params
+ * @param {{owner: string, repo: string}} params.repository
+ * @param {Function} [params.run]
+ * @returns {Promise<Array<object>>}
+ */
+export async function fetchOpenIssues({ repository, run = runCommand }) {
+  const output = await commandOutput(run, 'gh', buildOpenIssuesApiArgs({ owner: repository.owner, repo: repository.repo }));
+  const parsed = JSON.parse(output || '[]');
+  return Array.isArray(parsed) ? parsed : [];
+}
+
+/**
+ * Collect the data for the combined issue without creating anything.
+ *
+ * @param {object} params
+ * @param {{owner: string, repo: string, fullName: string, url: string}} params.repository
+ * @param {number} [params.limit=MAX_SUB_ISSUES_PER_PARENT]
+ * @param {Function} [params.run]
+ * @returns {Promise<{repository, selected, totalOpen, skipped, title, body}>}
+ */
+export async function prepareRepositoryModeIssue({ repository, limit = MAX_SUB_ISSUES_PER_PARENT, run = runCommand }) {
+  const entries = await fetchOpenIssues({ repository, run });
+  const { selected, totalOpen, skipped } = selectOldestOpenIssues(entries, { limit });
+
+  return {
+    repository,
+    selected,
+    totalOpen,
+    skipped,
+    limit,
+    title: buildCombinedIssueTitle({ owner: repository.owner, repo: repository.repo, count: selected.length, totalOpen }),
+    body: buildCombinedIssueBody({ repository, issues: selected, totalOpen, limit }),
+  };
+}
+
+/**
+ * Attach the selected issues to the combined issue as GitHub native sub-issues.
+ *
+ * Failures are non-fatal and reported: an issue that already has a different
+ * parent is rejected by the API, and losing the whole run over one such issue
+ * would be worse than solving the rest (the issue is still listed in the
+ * combined issue body either way).
+ *
+ * A rate-limited attachment is retried with a bounded backoff, and the requests
+ * are spaced out, because this endpoint is explicitly documented as prone to
+ * secondary rate limiting when content is created quickly.
+ *
+ * @param {object} params
+ * @param {{owner: string, repo: string, number: number}} params.parentIssue
+ * @param {Array<{number: number, id: number}>} params.issues
+ * @param {Function} [params.run]
+ * @param {Function} [params.log]
+ * @param {number} [params.delayMs] - pause between requests (0 disables it)
+ * @param {number} [params.maxAttempts] - attempts per sub-issue on rate limits
+ * @param {Function} [params.sleep] - test override for the waiting
+ * @returns {Promise<{attached: Array<object>, failed: Array<{issue: object, error: string}>}>}
+ */
+export async function attachSubIssues({ parentIssue, issues, run = runCommand, log = null, delayMs = SUB_ISSUE_ATTACH_DELAY_MS, maxAttempts = SUB_ISSUE_ATTACH_MAX_ATTEMPTS, sleep = defaultSleep }) {
+  const attached = [];
+  const failed = [];
+  const list = Array.isArray(issues) ? issues : [];
+
+  for (let index = 0; index < list.length; index++) {
+    const issue = list[index];
+    if (index > 0 && delayMs > 0) await sleep(delayMs);
+
+    let lastError = null;
+    for (let attempt = 1; attempt <= Math.max(1, maxAttempts); attempt++) {
+      try {
+        if (!Number.isInteger(issue.id) || issue.id <= 0) {
+          throw new Error(`missing REST id for issue #${issue.number}`);
+        }
+        await commandOutput(run, 'gh', buildAddSubIssueApiArgs({ parentIssue, subIssueId: issue.id }));
+        lastError = null;
+        break;
+      } catch (error) {
+        lastError = error;
+        // Only rate limits are worth retrying: "already has a parent" and the
+        // like would fail identically however long we wait.
+        if (attempt >= Math.max(1, maxAttempts) || !isRateLimitError(error)) break;
+        const waitMs = SUB_ISSUE_ATTACH_BACKOFF_MS[Math.min(attempt - 1, SUB_ISSUE_ATTACH_BACKOFF_MS.length - 1)];
+        await log?.(`   ⏳ Rate limited while attaching #${issue.number}; retrying in ${Math.round(waitMs / 1000)}s (attempt ${attempt + 1}/${maxAttempts})...`);
+        await sleep(waitMs);
+      }
+    }
+
+    if (lastError) {
+      const message = lastError?.message ? String(lastError.message).split('\n')[0] : String(lastError);
+      failed.push({ issue, error: message });
+      await log?.(`   ⚠️  Could not attach #${issue.number} as a sub-issue: ${message}`);
+    } else {
+      attached.push(issue);
+    }
+  }
+
+  return { attached, failed };
+}
+
+/**
+ * Create the combined issue and attach the sub-issues.
+ *
+ * @param {object} params
+ * @returns {Promise<{owner, repo, number, url, prepared, attached, failed}>}
+ */
+export async function createRepositoryModeIssue({ repository, prepared, run = runCommand, log = null, attachOptions = {} }) {
+  const issue = await createTaskIssue({
+    repository,
+    title: prepared.title,
+    body: prepared.body,
+    labels: [...REPOSITORY_MODE_ISSUE_LABELS],
+    run,
+    log,
+  });
+
+  const { attached, failed } = await attachSubIssues({
+    parentIssue: { owner: issue.owner, repo: issue.repo, number: issue.number },
+    issues: prepared.selected,
+    run,
+    log,
+    ...attachOptions,
+  });
+
+  return { ...issue, prepared, attached, failed };
+}
+
+/**
+ * Entry point used by solve.mjs.
+ *
+ * Returns `{ handled: false }` when the URL is not a repository URL so the
+ * caller can continue with its normal issue/pull-request validation.
+ *
+ * @param {object} params
+ * @param {string} params.url
+ * @param {Function} [params.log]
+ * @param {Function} [params.run]
+ * @param {number} [params.limit]
+ * @param {boolean} [params.dryRun] - prepare only; do not create anything
+ * @param {object} [params.attachOptions] - forwarded to {@link attachSubIssues}
+ * @returns {Promise<{handled: boolean, issueUrl?: string, issue?: object, prepared?: object, argvOverrides?: object, error?: string}>}
+ */
+export async function resolveRepositoryModeTarget({ url, log = null, run = runCommand, limit = MAX_SUB_ISSUES_PER_PARENT, dryRun = false, attachOptions = {} }) {
+  const repository = parseRepositoryModeUrl(url);
+  if (!repository) return { handled: false };
+
+  const emit = async message => {
+    if (typeof log === 'function') await log(message);
+  };
+
+  await emit('');
+  await emit(`📦 REPOSITORY MODE: ${repository.url}`);
+  await emit('   Collecting all open issues to combine them into a single issue...');
+
+  let prepared;
+  try {
+    prepared = await prepareRepositoryModeIssue({ repository, limit, run });
+  } catch (error) {
+    return { handled: true, error: `Could not list open issues of ${repository.fullName}: ${error.message}` };
+  }
+
+  for (const line of buildRepositoryModeSummaryLines({ totalOpen: prepared.totalOpen, selectedCount: prepared.selected.length, skipped: prepared.skipped, limit })) {
+    await emit(line);
+  }
+
+  if (prepared.selected.length === 0) {
+    return { handled: true, error: `${repository.fullName} has no open issues to solve.` };
+  }
+
+  if (dryRun) {
+    return { handled: true, dryRun: true, prepared };
+  }
+
+  await emit('');
+  await emit('📝 Creating the combined issue...');
+  await emit(`   Then attaching ${prepared.selected.length} issue(s) as sub-issues, one request per second to stay clear of GitHub's secondary rate limit...`);
+
+  let issue;
+  try {
+    issue = await createRepositoryModeIssue({ repository, prepared, run, log: emit, attachOptions });
+  } catch (error) {
+    return { handled: true, error: `Could not create the combined issue in ${repository.fullName}: ${error.message}` };
+  }
+
+  await emit(`✅ Created combined issue: ${issue.url}`);
+  await emit(`   Sub-issues attached: ${issue.attached.length}/${prepared.selected.length}${issue.failed.length > 0 ? ` (${issue.failed.length} could not be attached)` : ''}`);
+  await emit('   Continuing with the normal /solve flow for that issue.');
+  await emit('');
+
+  return {
+    handled: true,
+    issueUrl: issue.url,
+    issue,
+    prepared,
+    // Repository mode always asks for deep analysis (like /fix) and always
+    // double checks that the pull request description lists every issue.
+    argvOverrides: {
+      'deep-analysis': true,
+      deepAnalysis: true,
+      'ensure-all-sub-issues-addressed': true,
+      ensureAllSubIssuesAddressed: true,
+    },
+  };
+}
+
+export default {
+  REPOSITORY_MODE_ISSUE_LABELS,
+  SUB_ISSUE_ATTACH_DELAY_MS,
+  parseRepositoryModeUrl,
+  fetchOpenIssues,
+  prepareRepositoryModeIssue,
+  attachSubIssues,
+  createRepositoryModeIssue,
+  resolveRepositoryModeTarget,
+};

package/src/telegram-bot.mjs

@@ -612,7 +612,10 @@ async function handleSolveCommand(ctx) {
     return;
   }
 
-  const validation = await validateGitHubUrl(userArgs, { createYargsConfig: createSolveYargsConfig, positionalNames: ['issue-url'], locale: solveLocale });
+  // Issue #2212: a repository URL is accepted too — solve then collects every open
+  // issue of that repository into one combined issue (with GitHub native sub-issues)
+  // and solves that issue, so a single pull request can close all of them.
+  const validation = await validateGitHubUrl(userArgs, { allowedTypes: ['issue', 'pull', 'repo'], createYargsConfig: createSolveYargsConfig, positionalNames: ['issue-url'], locale: solveLocale });
   if (!validation.valid) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) {
@@ -705,7 +708,7 @@ async function handleSolveCommand(ctx) {
   let infoBlock = buildTelegramInfoBlock({
     locale: solveLocale,
     requester,
-    urlKind: validation.parsed?.type === 'pull' ? 'pullRequest' : 'issue',
+    urlKind: validation.parsed?.type === 'pull' ? 'pullRequest' : validation.parsed?.type === 'repo' ? 'url' : 'issue', // #2212: a repository URL is neither an issue nor a pull request
     url: escapeMarkdown(normalizedUrl),
     optionsRaw: userOptionsRaw ? escapeMarkdown(userOptionsRaw) : '',
     lockedOptions: solveOverrides.length > 0 ? escapeMarkdown(solveOverrides.join(' ')) : '',