@link-assistant/hive-mind 1.78.6 → 1.78.8

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @link-assistant/hive-mind
 
+## 1.78.8
+
+### Patch Changes
+
+- cb4986f: Close linked issues when a PR is merged into a non-default branch, and stop misreporting the cause (#1895).
+
+  GitHub only registers a PR's `closingIssuesReferences` and auto-closes the linked
+  issue when the PR targets the repository's **default branch**. PRs created against a
+  stacked / sub-issue branch (e.g. `issue-47-…` via `--base-branch`) therefore showed
+  an empty closing-reference connection and left their issues open after merge — the
+  exact failure reported for meta-language PRs #65/#66 / issues #49/#50.
+  - src/github-issue-auto-close.lib.mjs (new): `gitHubAutoClosesOnMerge`,
+    `classifyIssueLinkStatus`, `buildNonDefaultBranchExplanation`, and
+    `ensureLinkedIssueClosedAfterMerge` — diagnose why a closing reference is missing
+    and explicitly close the linked issue after a non-default-base merge (no-op when
+    GitHub already handles it, the keyword is absent, or the issue is already closed).
+  - src/solve.auto-pr.lib.mjs: replace the misleading "ISSUE LINK MISSING — add
+    Fixes #N" warning with an accurate "ISSUE LINK DEFERRED" explanation when the
+    keyword is present but the PR targets a non-default branch.
+  - src/solve.auto-continue.lib.mjs (`collectIssuePrCandidates`): detect the existing
+    PR for an issue by BOTH GitHub's `linked:issue` search (legacy, preserved) and the
+    deterministic `head:issue-N-` branch search. A PR targeting a non-default base
+    branch never appears in `linked:issue`, so `--auto-continue` previously failed to
+    resume it and risked creating a duplicate; the head-branch search guarantees the
+    PR↔issue association regardless of base branch.
+  - src/solve.auto-merge.lib.mjs (watchUntilMergeable + attemptAutoMerge),
+    src/github-merge.lib.mjs / src/github-merge-issue-close.lib.mjs
+    (`closeLinkedIssueIfNotAutoClosed`, used by the /merge queue), and
+    src/telegram-merge-queue.lib.mjs: close the linked issue explicitly after a merge
+    into a non-default branch. All gh calls route through the rate-limit-aware wrappers.
+  - tests/github-issue-auto-close.test.mjs: 14 cases reproducing the non-default-base
+    bug and verifying the diagnosis + fallback.
+  - tests/solve-auto-continue-detection-1895.test.mjs: 7 cases proving non-default-base
+    PRs are detected for auto-continue (head-branch search), legacy linked detection is
+    preserved, results are deduped/merged, and search failures degrade gracefully.
+  - docs/case-studies/issue-1895: deep case study with downloaded GraphQL/PR/issue
+    evidence, reconstructed timeline, root-cause analysis, requirement mapping, and the
+    external-reporting decision. Includes `github-api-linking-research.md` — a
+    definitive, introspection-backed answer to "is there an API to link a PR to an
+    issue?" (no: confirmed via live GraphQL schema introspection), with the gap
+    reported upstream (GitHub Community discussions #112224 / #155339 / #179613).
+
+## 1.78.7
+
+### Patch Changes
+
+- c1617ae: Fix `/task` issue creation when replying to a message: combine the inline command (e.g. the repository URL) with the replied-to message (the issue text) instead of dropping the reply, so replying with `/task <repository-url>` now creates the GitHub issue (issue #1916).
+
 ## 1.78.6
 
 ### Patch Changes

package/package.json

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

package/src/github-issue-auto-close.lib.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub Issue Auto-Close Diagnosis & Fallback Library
+ *
+ * Root cause of issue #1895:
+ * GitHub only registers a pull request's closing references (the
+ * `closingIssuesReferences` GraphQL connection) and only auto-closes the
+ * referenced issues when the pull request targets the repository's
+ * **default branch**. When a PR uses a closing keyword such as
+ * `Fixes #49` / `Closes #50` but targets a non-default branch (for example a
+ * stacked / sub-issue branch like `issue-47-...`), GitHub:
+ *
+ *   1. leaves `closingIssuesReferences` empty, so automatic linking detection
+ *      reports "ISSUE LINK MISSING" even though the keyword is present, and
+ *   2. does not close the linked issue when the PR is merged, so the PR is
+ *      "closed without its issue to be closed as well".
+ *
+ * This module provides:
+ *   - pure helpers to diagnose *why* a closing reference is missing, and
+ *   - an action helper that explicitly closes the linked issue after a merge
+ *     into a non-default branch, where GitHub would not do it for us.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1895
+ * @see https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+ */
+
+import { prClosesIssue, extractLinkedIssueNumber } from './github-linking.lib.mjs';
+import { wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs';
+
+/**
+ * Determine whether GitHub will automatically close a PR's linked issues when
+ * the PR is merged, based on the branch it targets.
+ *
+ * GitHub only auto-closes linked issues for PRs merged into the repository's
+ * default branch.
+ *
+ * @param {string|null|undefined} baseBranch - The branch the PR targets (baseRefName)
+ * @param {string|null|undefined} defaultBranch - The repository's default branch
+ * @returns {boolean|null} true if GitHub will auto-close, false if it will not,
+ *   or null when the answer cannot be determined (missing input).
+ */
+export function gitHubAutoClosesOnMerge(baseBranch, defaultBranch) {
+  if (!baseBranch || !defaultBranch) {
+    return null;
+  }
+  return String(baseBranch).trim() === String(defaultBranch).trim();
+}
+
+/**
+ * Classify the issue-linking status of a pull request so callers can emit an
+ * accurate diagnostic instead of the misleading "add Fixes #N" advice when the
+ * keyword is already present.
+ *
+ * @param {Object} options
+ * @param {string|null} [options.prBody] - Pull request body
+ * @param {string|null} [options.prTitle] - Pull request title
+ * @param {string|number} options.issueNumber - Issue the PR should close
+ * @param {string|null} [options.owner] - Repository owner (for cross-repo refs)
+ * @param {string|null} [options.repo] - Repository name (for cross-repo refs)
+ * @param {string|null} [options.baseBranch] - Branch the PR targets
+ * @param {string|null} [options.defaultBranch] - Repository default branch
+ * @param {boolean} [options.githubLinked] - Whether GitHub already reports the
+ *   issue in `closingIssuesReferences`
+ * @returns {{
+ *   hasClosingKeyword: boolean,
+ *   githubLinked: boolean,
+ *   autoCloses: boolean|null,
+ *   targetsNonDefaultBranch: boolean,
+ *   requiresManualClose: boolean,
+ *   reason: string,
+ * }}
+ */
+export function classifyIssueLinkStatus({ prBody = '', prTitle = '', issueNumber, owner = null, repo = null, baseBranch = null, defaultBranch = null, githubLinked = false } = {}) {
+  const hasClosingKeyword = prClosesIssue(prBody, issueNumber, owner, repo) || prClosesIssue(prTitle, issueNumber, owner, repo);
+  const autoCloses = gitHubAutoClosesOnMerge(baseBranch, defaultBranch);
+  const targetsNonDefaultBranch = autoCloses === false;
+
+  let reason;
+  let requiresManualClose = false;
+
+  if (githubLinked) {
+    reason = 'github-linked';
+  } else if (!hasClosingKeyword) {
+    // The keyword is genuinely absent — the historical advice applies.
+    reason = 'missing-keyword';
+  } else if (targetsNonDefaultBranch) {
+    // The keyword IS present, but the PR targets a non-default branch, so
+    // GitHub never registers the closing reference and will not auto-close.
+    reason = 'non-default-base-branch';
+    requiresManualClose = true;
+  } else {
+    // Keyword present, base looks like default (or unknown): GitHub is
+    // expected to register the link, possibly after a short delay.
+    reason = 'keyword-present-link-pending';
+  }
+
+  return {
+    hasClosingKeyword,
+    githubLinked: Boolean(githubLinked),
+    autoCloses,
+    targetsNonDefaultBranch,
+    requiresManualClose,
+    reason,
+  };
+}
+
+/**
+ * Build the human-readable lines that explain a non-default-base-branch linking
+ * failure. Shared so solve and merge code paths print the same explanation.
+ *
+ * @param {Object} options
+ * @param {string|number} options.issueNumber
+ * @param {string} options.baseBranch
+ * @param {string} options.defaultBranch
+ * @param {string} [options.issueRef] - Display reference such as `#49` or `owner/repo#49`
+ * @returns {string[]}
+ */
+export function buildNonDefaultBranchExplanation({ issueNumber, baseBranch, defaultBranch, issueRef = `#${issueNumber}` }) {
+  return [`The PR closing keyword for ${issueRef} is present, but the PR targets the`, `non-default branch '${baseBranch}' (the repository default is '${defaultBranch}').`, 'GitHub only registers closing references and auto-closes linked issues for', 'pull requests merged into the default branch, so:', `  • the automatic link to issue ${issueRef} will not appear, and`, `  • issue ${issueRef} will NOT be closed automatically when this PR merges.`, 'hive-mind will close the linked issue explicitly after the merge instead.'];
+}
+
+/**
+ * After a PR has been merged, ensure the linked issue is closed when GitHub will
+ * not do it automatically (i.e. the PR targeted a non-default branch).
+ *
+ * This is a no-op (returns a skipped result) when:
+ *   - GitHub will auto-close the issue (PR merged into the default branch), or
+ *   - the PR body/title does not contain a closing keyword for the issue, or
+ *   - the issue is already closed.
+ *
+ * @param {Object} options
+ * @param {Function} options.$ - command-stream `$` exec helper
+ * @param {Function} [options.log] - async logger
+ * @param {string} options.owner
+ * @param {string} options.repo
+ * @param {string|number} options.prNumber
+ * @param {string|number|null} [options.issueNumber] - Issue the PR should close
+ *   (derived from the PR body closing keyword when omitted)
+ * @param {string|null} [options.baseBranch] - Branch the PR targeted (fetched if omitted)
+ * @param {string|null} [options.defaultBranch] - Repo default branch (fetched if omitted)
+ * @param {string|null} [options.prBody] - PR body (fetched if omitted)
+ * @param {string|null} [options.prTitle] - PR title (fetched if omitted)
+ * @param {boolean} [options.verbose]
+ * @returns {Promise<{closed: boolean, skipped: boolean, reason: string, error?: string}>}
+ */
+export async function ensureLinkedIssueClosedAfterMerge({ $: rawDollar, log = null, owner, repo, prNumber, issueNumber = null, baseBranch = null, defaultBranch = null, prBody = null, prTitle = null, verbose = false }) {
+  // Issue #1726: route every `gh ...` call through the rate-limit-aware wrapper.
+  const $ = wrapDollarWithGhRetry(rawDollar);
+  const note = async message => {
+    if (log) {
+      await log(message, { verbose: true });
+    } else if (verbose) {
+      console.log(message);
+    }
+  };
+
+  if (!owner || !repo || !prNumber) {
+    return { closed: false, skipped: true, reason: 'missing-parameters' };
+  }
+
+  try {
+    // Fetch PR metadata (base branch, body, title) if not provided.
+    if (baseBranch === null || prBody === null || prTitle === null) {
+      const prView = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json baseRefName,body,title`;
+      if (prView.code === 0) {
+        const data = JSON.parse(prView.stdout.toString().trim() || '{}');
+        if (baseBranch === null) baseBranch = data.baseRefName ?? null;
+        if (prBody === null) prBody = data.body ?? '';
+        if (prTitle === null) prTitle = data.title ?? '';
+      }
+    }
+
+    // Derive the linked issue from the PR body when the caller did not supply it.
+    if (!issueNumber) {
+      issueNumber = extractLinkedIssueNumber(prBody || '') || extractLinkedIssueNumber(prTitle || '');
+    }
+    if (!issueNumber) {
+      await note(`[auto-close] PR #${prNumber} has no closing keyword identifying an issue; nothing to close`);
+      return { closed: false, skipped: true, reason: 'no-linked-issue' };
+    }
+
+    // Fetch the repository default branch if not provided.
+    if (defaultBranch === null) {
+      const repoView = await $`gh api repos/${owner}/${repo} --jq .default_branch`;
+      if (repoView.code === 0) {
+        defaultBranch = repoView.stdout.toString().trim() || null;
+      }
+    }
+
+    const status = classifyIssueLinkStatus({ prBody: prBody || '', prTitle: prTitle || '', issueNumber, owner, repo, baseBranch, defaultBranch });
+
+    if (status.autoCloses === true) {
+      await note(`[auto-close] GitHub will auto-close issue #${issueNumber} (PR #${prNumber} merged into default branch '${defaultBranch}')`);
+      return { closed: false, skipped: true, reason: 'github-auto-closes' };
+    }
+
+    if (!status.hasClosingKeyword) {
+      await note(`[auto-close] PR #${prNumber} has no closing keyword for issue #${issueNumber}; not closing it`);
+      return { closed: false, skipped: true, reason: 'no-closing-keyword' };
+    }
+
+    if (status.autoCloses === null) {
+      await note(`[auto-close] Could not determine base/default branch for PR #${prNumber}; leaving issue #${issueNumber} to GitHub`);
+      return { closed: false, skipped: true, reason: 'unknown-branch' };
+    }
+
+    // Check current issue state — do not act if it is already closed.
+    const issueState = await $`gh issue view ${issueNumber} --repo ${owner}/${repo} --json state,stateReason`;
+    if (issueState.code === 0) {
+      const data = JSON.parse(issueState.stdout.toString().trim() || '{}');
+      if (String(data.state).toUpperCase() === 'CLOSED') {
+        await note(`[auto-close] Issue #${issueNumber} is already closed`);
+        return { closed: false, skipped: true, reason: 'already-closed' };
+      }
+    }
+
+    // Close the issue explicitly, leaving an explanatory trail.
+    const comment = [`Closed by #${prNumber}, which targeted the non-default branch \`${baseBranch}\` (repository default: \`${defaultBranch}\`).`, '', 'GitHub only auto-closes linked issues for pull requests merged into the default branch,', 'so hive-mind closed this issue explicitly after the merge.', '', '_Automated by hive-mind ([#1895](https://github.com/link-assistant/hive-mind/issues/1895))._'].join('\n');
+
+    const closeResult = await $`gh issue close ${issueNumber} --repo ${owner}/${repo} --reason completed --comment ${comment}`;
+    if (closeResult.code === 0) {
+      if (log) {
+        await log(`🔗 Closed issue #${issueNumber} explicitly (PR #${prNumber} merged into non-default branch '${baseBranch}')`);
+      }
+      return { closed: true, skipped: false, reason: 'closed-explicitly' };
+    }
+
+    return { closed: false, skipped: false, reason: 'close-command-failed', error: closeResult.stderr?.toString?.() || 'unknown error' };
+  } catch (error) {
+    return { closed: false, skipped: false, reason: 'exception', error: error.message };
+  }
+}
+
+export default {
+  gitHubAutoClosesOnMerge,
+  classifyIssueLinkStatus,
+  buildNonDefaultBranchExplanation,
+  ensureLinkedIssueClosedAfterMerge,
+};

package/src/github-merge-issue-close.lib.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * GitHub Merge — Linked Issue Close Helper
+ *
+ * Issue #1895: After merging a PR, GitHub only auto-closes the linked issue when
+ * the PR targeted the repository's default branch. For PRs merged into a
+ * non-default branch (e.g. a stacked / sub-issue branch), the linked issue stays
+ * open even though the PR body contains a valid `Fixes #N` keyword. This helper
+ * closes the linked issue explicitly in that case.
+ *
+ * Extracted from github-merge.lib.mjs to keep that file under the 1500-line
+ * limit (same rationale as the Issue #1413 ready-sync split).
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1895
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+import { githubLimits } from './config.lib.mjs';
+import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { extractLinkedIssueNumber } from './github-linking.lib.mjs';
+import { classifyIssueLinkStatus } from './github-issue-auto-close.lib.mjs';
+import { getDefaultBranch } from './github-merge.lib.mjs';
+
+const execRaw = promisify(execCallback);
+
+// Issue #1726: keep every gh call rate-limit safe (mirrors github-merge.lib.mjs).
+const exec = (cmd, opts = {}) =>
+  ghWithRateLimitRetry(() => execRaw(cmd, { maxBuffer: githubLimits.bufferMaxSize, ...opts }), {
+    label: `gh exec (${cmd.split(/\s+/).slice(0, 3).join(' ')})`,
+  });
+
+/**
+ * After merging a PR, explicitly close the linked issue when GitHub will not
+ * auto-close it (i.e. the PR targeted a non-default branch).
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Merged pull request number
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{closed: boolean, skipped: boolean, reason: string, issueNumber?: number}>}
+ */
+export async function closeLinkedIssueIfNotAutoClosed(owner, repo, prNumber, verbose = false) {
+  try {
+    const { stdout: prJson } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json baseRefName,body,title`);
+    const pr = JSON.parse(prJson.trim() || '{}');
+    const baseBranch = pr.baseRefName || null;
+    const prBody = pr.body || '';
+    const prTitle = pr.title || '';
+
+    const issueNumber = extractLinkedIssueNumber(prBody) || extractLinkedIssueNumber(prTitle);
+    if (!issueNumber) {
+      if (verbose) console.log(`[VERBOSE] /merge: PR #${prNumber} has no closing keyword; no issue to close`);
+      return { closed: false, skipped: true, reason: 'no-linked-issue' };
+    }
+
+    const defaultBranch = await getDefaultBranch(owner, repo, verbose);
+    const status = classifyIssueLinkStatus({ prBody, prTitle, issueNumber, owner, repo, baseBranch, defaultBranch });
+
+    if (status.autoCloses !== false) {
+      // GitHub handles it (default branch) or branch info is unknown.
+      if (verbose) console.log(`[VERBOSE] /merge: Issue #${issueNumber} will be handled by GitHub (base '${baseBranch}', default '${defaultBranch}')`);
+      return { closed: false, skipped: true, reason: status.autoCloses === true ? 'github-auto-closes' : 'unknown-branch', issueNumber: Number(issueNumber) };
+    }
+
+    // Skip if already closed.
+    try {
+      const { stdout: issueJson } = await exec(`gh issue view ${issueNumber} --repo ${owner}/${repo} --json state`);
+      const issue = JSON.parse(issueJson.trim() || '{}');
+      if (String(issue.state).toUpperCase() === 'CLOSED') {
+        if (verbose) console.log(`[VERBOSE] /merge: Issue #${issueNumber} already closed`);
+        return { closed: false, skipped: true, reason: 'already-closed', issueNumber: Number(issueNumber) };
+      }
+    } catch {
+      // If state lookup fails, fall through and attempt the close.
+    }
+
+    const comment = `Closed by #${prNumber}, which targeted the non-default branch \`${baseBranch}\` (repository default: \`${defaultBranch}\`).\n\nGitHub only auto-closes linked issues for pull requests merged into the default branch, so hive-mind closed this issue explicitly after the merge.\n\n_Automated by hive-mind ([#1895](https://github.com/link-assistant/hive-mind/issues/1895))._`;
+    await exec(`gh issue close ${issueNumber} --repo ${owner}/${repo} --reason completed --comment ${JSON.stringify(comment)}`);
+    if (verbose) console.log(`[VERBOSE] /merge: Closed issue #${issueNumber} explicitly (PR #${prNumber} merged into non-default branch '${baseBranch}')`);
+    return { closed: true, skipped: false, reason: 'closed-explicitly', issueNumber: Number(issueNumber) };
+  } catch (error) {
+    if (verbose) console.log(`[VERBOSE] /merge: Error closing linked issue for PR #${prNumber}: ${error.message}`);
+    return { closed: false, skipped: false, reason: 'exception', error: error.message };
+  }
+}
+
+export default { closeLinkedIssueIfNotAutoClosed };

package/src/github-merge.lib.mjs

@@ -42,6 +42,12 @@ const exec = (cmd, opts = {}) =>
 import { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL } from './github-merge-ready-sync.lib.mjs';
 export { syncReadyTags, getLinkedPRsFromTimeline, READY_LABEL };
 
+// Issue #1895: After merging into a non-default branch, close the linked issue
+// explicitly (GitHub only auto-closes for default-branch merges). Extracted to a
+// separate module to keep this file under the 1500-line limit.
+import { closeLinkedIssueIfNotAutoClosed } from './github-merge-issue-close.lib.mjs';
+export { closeLinkedIssueIfNotAutoClosed };
+
 /**
  * Check if 'ready' label exists in repository
  * @param {string} owner - Repository owner
@@ -1419,6 +1425,7 @@ export default {
   getActiveBranchRuns, // Issue #1307: New exports for target branch CI waiting
   waitForBranchCI,
   getDefaultBranch,
+  closeLinkedIssueIfNotAutoClosed, // Issue #1895: close linked issue after merge into non-default branch
   // Issue #1314: Billing limit detection and enhanced CI status and re-run capabilities
   getCheckRunAnnotations,
   getRepoVisibility,

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

@@ -248,6 +248,65 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
   }
 };
 
+/**
+ * Collect candidate PRs for an issue from two complementary sources, deduped by
+ * PR number.
+ *
+ * Issue #1895: a pull request that targets a NON-default base branch (for
+ * example a stacked sub-issue branch like `issue-47-...`, or any PR created with
+ * `--base-branch <not-main>`) never appears in GitHub's `linked:issue` search,
+ * because GitHub only registers closing references for PRs merged into the
+ * repository's default branch. Relying on the `linked:issue` search alone makes
+ * `--auto-continue` blind to those PRs and silently create a duplicate. We
+ * therefore ALSO search by the deterministic `issue-{N}-{hash}` head-branch
+ * name, which is a reliable signal regardless of which base branch the PR
+ * targets. Source 1 (the legacy `linked:issue` search) is preserved so previous
+ * linking behavior is unchanged; source 2 only ever adds PRs that source 1
+ * would have missed.
+ *
+ * The two result sets are merged and deduped by PR number; callers still apply
+ * `matchesIssuePattern` to reject any unrelated branch the search may surface.
+ *
+ * @param {Object} options
+ * @param {Function} options.$ - command-stream `$` exec helper (injected for testability)
+ * @param {string} options.owner
+ * @param {string} options.repo
+ * @param {string|number} options.issueNumber
+ * @returns {Promise<Array<{number:number, createdAt?:string, headRefName?:string, isDraft?:boolean, state?:string}>>}
+ */
+export const collectIssuePrCandidates = async ({ $: dollar = $, owner, repo, issueNumber }) => {
+  const candidates = new Map();
+  const collect = result => {
+    if (!result || result.code !== 0) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(result.stdout.toString().trim() || '[]');
+    } catch {
+      parsed = [];
+    }
+    for (const pr of parsed) {
+      if (pr && pr.number !== undefined && pr.number !== null) {
+        // Keep the first occurrence; the linked search runs first and both
+        // sources return the same shape, so dedup order is irrelevant.
+        if (!candidates.has(pr.number)) {
+          candidates.set(pr.number, pr);
+        }
+      }
+    }
+  };
+
+  // Source 1 (legacy behavior, preserved): PRs GitHub reports as linked.
+  collect(await dollar`gh pr list --repo ${owner}/${repo} --search "linked:issue-${issueNumber}" --json number,createdAt,headRefName,isDraft,state --limit 10`);
+
+  // Source 2 (issue #1895): PRs whose head branch matches this issue's naming
+  // convention — reliably surfaces PRs targeting a non-default base branch.
+  collect(await dollar`gh pr list --repo ${owner}/${repo} --search "head:${getIssueBranchPrefix(issueNumber)}" --json number,createdAt,headRefName,isDraft,state --limit 20`);
+
+  return [...candidates.values()];
+};
+
 // Auto-continue logic: check for existing PRs if --auto-continue is enabled
 export const checkExistingPRsForAutoContinue = async (argv, isIssueUrl, owner, repo, urlNumber) => {
   let isContinueMode = false;
@@ -260,14 +319,14 @@ export const checkExistingPRsForAutoContinue = async (argv, isIssueUrl, owner, r
     await log(`🔍 Auto-continue enabled: Checking for existing PRs for issue #${issueNumber}...`);
 
     try {
-      // Get all PRs linked to this issue
-      const prListResult = await $`gh pr list --repo ${owner}/${repo} --search "linked:issue-${issueNumber}" --json number,createdAt,headRefName,isDraft,state --limit 10`;
-
-      if (prListResult.code === 0) {
-        const prs = JSON.parse(prListResult.stdout.toString().trim() || '[]');
+      // Get all candidate PRs for this issue. Issue #1895: this includes PRs
+      // targeting a non-default base branch (found by head-branch name), which
+      // GitHub's `linked:issue` search omits.
+      const prs = await collectIssuePrCandidates({ $, owner, repo, issueNumber });
 
+      {
         if (prs.length > 0) {
-          await log(`📋 Found ${prs.length} existing PR(s) linked to issue #${issueNumber}`);
+          await log(`📋 Found ${prs.length} existing PR(s) for issue #${issueNumber}`);
 
           // Find PRs that are older than 24 hours
           const now = new Date();
@@ -535,14 +594,15 @@ export const processAutoContinueForIssue = async (argv, isIssueUrl, urlNumber, o
   }
 
   try {
-    // Get all PRs linked to this issue
-    const prListResult = await $`gh pr list --repo ${owner}/${repo} --search "linked:issue-${issueNumber}" --json number,createdAt,headRefName,isDraft,state --limit 10`;
-
-    if (prListResult.code === 0) {
-      const prs = JSON.parse(prListResult.stdout.toString().trim() || '[]');
+    // Get all candidate PRs for this issue. Issue #1895: this includes PRs
+    // targeting a non-default base branch (found by head-branch name), which
+    // GitHub's `linked:issue` search omits — critical so --auto-continue
+    // detects and resumes the existing PR instead of creating a duplicate.
+    const prs = await collectIssuePrCandidates({ $, owner, repo, issueNumber });
 
+    {
       if (prs.length > 0) {
-        await log(`📋 Found ${prs.length} existing PR(s) linked to issue #${issueNumber}`);
+        await log(`📋 Found ${prs.length} existing PR(s) for issue #${issueNumber}`);
 
         // Find PRs that are older than 24 hours
         const now = new Date();

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

@@ -77,6 +77,10 @@ const { maybeAttachWorkingSessionSummary, ensurePullRequestIssueLink } = results
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
 const { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIterationLimit, shouldSyncBeforeRestart } = await import('./auto-iteration-limits.lib.mjs');
 
+// Issue #1895: explicitly close linked issues after merging a PR into a
+// non-default branch, where GitHub does not auto-close them.
+const { ensureLinkedIssueClosedAfterMerge } = await import('./github-issue-auto-close.lib.mjs');
+
 const shouldDeleteBranchAfterMerge = argv => argv.autoDeleteBranchOnMerge || argv.deleteBranchAfterMerge || false;
 
 /**
@@ -309,6 +313,22 @@ export const watchUntilMergeable = async params => {
               // Don't fail if comment posting fails
             }
 
+            // Issue #1895: when the PR targeted a non-default branch GitHub does
+            // not auto-close the linked issue. Close it explicitly so the issue
+            // is not left open after its PR merges.
+            if (issueNumber) {
+              try {
+                const closeResult = await ensureLinkedIssueClosedAfterMerge({ $, log, owner, repo, prNumber, issueNumber, verbose: argv.verbose });
+                if (closeResult.skipped && argv.verbose) {
+                  await log(formatAligned('', 'Issue auto-close:', `skipped (${closeResult.reason})`, 2), { verbose: true });
+                } else if (!closeResult.closed && !closeResult.skipped) {
+                  await log(formatAligned('⚠️', 'Issue auto-close:', `could not close issue #${issueNumber} (${closeResult.reason})`, 2), { level: 'warning' });
+                }
+              } catch (closeError) {
+                await log(formatAligned('⚠️', 'Issue auto-close:', `error closing issue #${issueNumber}: ${closeError.message}`, 2), { level: 'warning' });
+              }
+            }
+
             return { success: true, reason: 'auto-merged', latestSessionId, latestAnthropicCost };
           } else {
             await log(formatAligned('⚠️', 'Auto-merge failed:', mergeResult.error || 'Unknown error', 2));
@@ -1171,7 +1191,7 @@ No further AI sessions will be started automatically for this run. Please review
  * This implements the --auto-merge functionality for one-shot merge attempts
  */
 export const attemptAutoMerge = async params => {
-  const { owner, repo, prNumber, argv } = params;
+  const { owner, repo, prNumber, issueNumber = null, argv } = params;
 
   await log('');
   await log(formatAligned('🔀', 'AUTO-MERGE:', 'Checking if PR can be merged...'));
@@ -1234,6 +1254,16 @@ export const attemptAutoMerge = async params => {
       // Don't fail if comment posting fails
     }
 
+    // Issue #1895: close linked issue explicitly when GitHub will not (non-default base branch).
+    try {
+      const closeResult = await ensureLinkedIssueClosedAfterMerge({ $, log, owner, repo, prNumber, issueNumber, verbose: argv.verbose });
+      if (!closeResult.closed && !closeResult.skipped) {
+        await log(formatAligned('⚠️', 'Issue auto-close:', `could not close linked issue (${closeResult.reason})`, 2), { level: 'warning' });
+      }
+    } catch (closeError) {
+      await log(formatAligned('⚠️', 'Issue auto-close:', `error: ${closeError.message}`, 2), { level: 'warning' });
+    }
+
     return { success: true, reason: 'merged' };
   } else {
     await log(formatAligned('⚠️', 'Merge failed:', mergeResult.error || 'Unknown error', 2));

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

@@ -4,6 +4,7 @@
  */
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
+import { classifyIssueLinkStatus, buildNonDefaultBranchExplanation } from './github-issue-auto-close.lib.mjs'; // Issue #1895: explain non-default-base-branch linking failures instead of the misleading "add Fixes #N" advice.
 import { handleRejectedPushForAutoPr, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
 import { emitForkAwareDiagnostic } from './solve.auto-pr-fork-diagnostic.lib.mjs';
 import { handleCompareApiNotReady } from './solve.auto-pr-compare-readiness.lib.mjs'; // Issue #1829: decides whether a failed compare-API readiness poll is fatal (fork mismatch / 0 commits) or a transient diff-render failure to degrade past.
@@ -1171,31 +1172,58 @@ ${prBody}`,
                   if (closingIssueNumbersContain(linkedIssues, issueNumber)) {
                     await log(formatAligned('✅', 'Link verified:', `Issue #${issueNumber} → PR #${localPrNumber}`));
                   } else {
-                    // This is a problem - the link wasn't created
-                    await log('');
-                    await log(formatAligned('⚠️', 'ISSUE LINK MISSING:', 'PR not linked to issue'), {
-                      level: 'warning',
+                    // The link wasn't registered by GitHub. Issue #1895: this is
+                    // expected (not a body problem) when the PR targets a
+                    // non-default branch, because GitHub only registers closing
+                    // references for PRs into the default branch. Diagnose the
+                    // real root cause instead of telling the user to add a
+                    // "Fixes #N" line that is already present.
+                    const targetBranch = argv.baseBranch || defaultBranch;
+                    const linkStatus = classifyIssueLinkStatus({
+                      prBody,
+                      issueNumber,
+                      owner,
+                      repo,
+                      baseBranch: targetBranch,
+                      defaultBranch,
+                      githubLinked: false,
                     });
-                    await log('');
 
-                    if (argv.fork) {
-                      await log("   The PR was created from a fork but wasn't linked to the issue.", {
-                        level: 'warning',
-                      });
-                      await log(`   Expected: "Fixes ${owner}/${repo}#${issueNumber}" in PR body`, {
-                        level: 'warning',
-                      });
+                    await log('');
+                    if (linkStatus.reason === 'non-default-base-branch') {
+                      // Keyword present + non-default base: GitHub will not
+                      // auto-close. This is handled later by the explicit
+                      // post-merge close fallback, so surface it as info.
+                      await log(formatAligned('ℹ️', 'ISSUE LINK DEFERRED:', `PR targets non-default branch '${targetBranch}'`));
                       await log('');
-                      await log('   To fix manually:', { level: 'warning' });
-                      await log(`   1. Edit the PR description at: ${prUrl}`, { level: 'warning' });
-                      await log(`   2. Add this line: Fixes ${owner}/${repo}#${issueNumber}`, { level: 'warning' });
+                      for (const line of buildNonDefaultBranchExplanation({ issueNumber, baseBranch: targetBranch, defaultBranch, issueRef })) {
+                        await log(`   ${line}`);
+                      }
                     } else {
-                      await log(`   The PR wasn't linked to issue #${issueNumber}`, { level: 'warning' });
-                      await log(`   Expected: "Fixes #${issueNumber}" in PR body`, { level: 'warning' });
+                      await log(formatAligned('⚠️', 'ISSUE LINK MISSING:', 'PR not linked to issue'), {
+                        level: 'warning',
+                      });
                       await log('');
-                      await log('   To fix manually:', { level: 'warning' });
-                      await log(`   1. Edit the PR description at: ${prUrl}`, { level: 'warning' });
-                      await log(`   2. Ensure it contains: Fixes #${issueNumber}`, { level: 'warning' });
+
+                      if (argv.fork) {
+                        await log("   The PR was created from a fork but wasn't linked to the issue.", {
+                          level: 'warning',
+                        });
+                        await log(`   Expected: "Fixes ${owner}/${repo}#${issueNumber}" in PR body`, {
+                          level: 'warning',
+                        });
+                        await log('');
+                        await log('   To fix manually:', { level: 'warning' });
+                        await log(`   1. Edit the PR description at: ${prUrl}`, { level: 'warning' });
+                        await log(`   2. Add this line: Fixes ${owner}/${repo}#${issueNumber}`, { level: 'warning' });
+                      } else {
+                        await log(`   The PR wasn't linked to issue #${issueNumber}`, { level: 'warning' });
+                        await log(`   Expected: "Fixes #${issueNumber}" in PR body`, { level: 'warning' });
+                        await log('');
+                        await log('   To fix manually:', { level: 'warning' });
+                        await log(`   1. Edit the PR description at: ${prUrl}`, { level: 'warning' });
+                        await log(`   2. Ensure it contains: Fixes #${issueNumber}`, { level: 'warning' });
+                      }
                     }
                     await log('');
                   }

package/src/task.issue-creation.lib.mjs

@@ -24,8 +24,13 @@ export function stripTaskCommandPrefix(text) {
 
 export function resolveTaskIssueCreationInput({ commandText = '', replyText = '' } = {}) {
   const inlineText = stripTaskCommandPrefix(commandText);
-  if (inlineText) return inlineText;
-  return normalizeNewlines(replyText).trim();
+  const reply = normalizeNewlines(replyText).trim();
+  // When replying to a message, the inline command and the replied-to message
+  // are complementary: one often carries the repository URL while the other
+  // carries the issue text (issue #1916). Combine both so neither part is lost.
+  // Inline text comes first so it takes precedence for title/body ordering.
+  if (inlineText && reply) return `${inlineText}\n${reply}`;
+  return inlineText || reply;
 }
 
 export function parseTaskRepository(value) {
@@ -72,6 +77,12 @@ function parseRepositoryLine(line) {
 function setRepository(currentRepository, nextRepository) {
   if (!nextRepository) return { repository: currentRepository };
   if (currentRepository) {
+    // The same repository may legitimately appear in both the inline command
+    // and the replied-to message once they are combined (issue #1916). Treat
+    // identical repositories as a no-op and only reject genuine conflicts.
+    if (currentRepository.fullName === nextRepository.fullName) {
+      return { repository: currentRepository };
+    }
     return {
       repository: currentRepository,
       error: 'Only one GitHub repository may be provided.',

package/src/telegram-merge-queue.lib.mjs

@@ -16,7 +16,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1143
  */
 
-import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch, waitForCommitCI, checkBranchCIHealth, getMergeCommitSha, getPRStatus, syncReadyTags } from './github-merge.lib.mjs';
+import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch, waitForCommitCI, checkBranchCIHealth, getMergeCommitSha, getPRStatus, syncReadyTags, closeLinkedIssueIfNotAutoClosed } from './github-merge.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
 
@@ -512,6 +512,17 @@ export class MergeQueueProcessor {
       this.stats.merged++;
       this.log(`Successfully merged PR #${item.pr.number}`);
 
+      // Issue #1895: GitHub does not auto-close linked issues for PRs merged into
+      // a non-default branch. Close the linked issue explicitly in that case.
+      try {
+        const closeResult = await closeLinkedIssueIfNotAutoClosed(this.owner, this.repo, item.pr.number, this.verbose);
+        if (closeResult.closed) {
+          this.log(`Closed linked issue #${closeResult.issueNumber} for PR #${item.pr.number} (merged into non-default branch)`);
+        }
+      } catch (closeError) {
+        this.log(`Could not close linked issue for PR #${item.pr.number}: ${closeError.message}`);
+      }
+
       // Issue #1341: Get the merge commit SHA for post-merge CI tracking
       // Need a small delay to allow GitHub to update the PR state
       await this.sleep(5000);

package/src/telegram-task-command.lib.mjs

@@ -131,10 +131,12 @@ export function registerTaskCommands(bot, options) {
     const splitMode = commandName === 'split' || hasTaskSplitFlag(parsedArgs);
 
     if (!splitMode) {
+      const replyText = getReplyText(ctx.message);
       const creationInput = resolveTaskIssueCreationInput({
         commandText: ctx.message.text,
-        replyText: getReplyText(ctx.message),
+        replyText,
       });
+      VERBOSE && console.log(`[VERBOSE] ${commandDisplay} issue creation: isReply=${Boolean(replyText)} replyChars=${replyText.length} resolvedChars=${creationInput.length}`);
       const creation = parseTaskIssueCreationInput(creationInput);
 
       if (!creation.valid) {