@link-assistant/hive-mind 2.11.0 → 2.11.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.11.2
+
+### Patch Changes
+
+- 2777cf5: Stop `/task --ci-cd` and `/fix --ci-cd` from listing the same workflow many times in the generated issue (issue #2125). When the latest default-branch commit has no workflow runs — typical for release commits — the collector falls back to the recent runs of the default branch, which span many commits; every one of them became a table row, so `link-assistant/agent#287` listed two workflows twenty times and reported "20 (9 not passing)". `dedupeRunsByWorkflow()` now keeps only the most recent run of each workflow (by `workflow_id`, then `path`/`name`, resolved with `created_at`/`run_attempt`/`id`), the failure summary counts the same deduplicated set, and the branch-fallback table gained a Commit column because its rows can come from different commits. The fallback fetches 100 runs instead of 20 so a rarely-run workflow still appears after collapsing, and `prepareCiCdIssue()` logs how many runs it collapsed.
+
+## 2.11.1
+
+### Patch Changes
+
+- aea5fe1: Put the pull request back into draft whenever a working session starts, restarts or resumes (issue #2123). Draft/ready transitions now live in one shared module (`src/pr-draft-state.lib.mjs`) that is called from `startWorkSession()` for every continue-mode session — the previous `--watch`/`--auto-continue` gate is gone — and from `executeToolIteration()`, which covers watch mode, temporary auto-restart on uncommitted changes, auto-restart-until-mergeable, escalate, keep-working and auto-ensure-requirements. Limit-reset auto-resume/auto-restart now also forwards `--auto-continue` so the resumed process re-attaches to the existing PR instead of running detached from it. The helper is a no-op for PRs that are already in the target state, merged or closed, and logs the observed `isDraft`/`state` under `--verbose`.
+
 ## 2.11.0
 
 ### Minor Changes

package/package.json

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

package/src/fix.ci-cd-issue.lib.mjs

@@ -4,7 +4,7 @@
  */
 
 import { spawn } from 'child_process';
-import { CI_CD_ISSUE_LABELS, CI_CD_ISSUE_TYPE, buildCiCdIssueBody, buildCiCdIssueTitle } from './fix.ci-cd.lib.mjs';
+import { CI_CD_ISSUE_LABELS, CI_CD_ISSUE_TYPE, buildCiCdIssueBody, buildCiCdIssueTitle, dedupeRunsByWorkflow } from './fix.ci-cd.lib.mjs';
 import { createTaskIssue } from './task.issue-creation.lib.mjs';
 
 function runCommand(command, args, options = {}) {
@@ -70,7 +70,9 @@ async function getLatestCommit(repository, branch, run, warn) {
   }
 }
 
-const RUNS_JQ = '[.workflow_runs[] | {name: .name, status: .status, conclusion: .conclusion, html_url: .html_url, head_sha: .head_sha}]';
+// `workflow_id`, `created_at` and `run_attempt` are what let
+// `dedupeRunsByWorkflow` keep the latest run of each workflow (issue #2125).
+const RUNS_JQ = '[.workflow_runs[] | {id: .id, name: .name, workflow_id: .workflow_id, path: .path, status: .status, conclusion: .conclusion, html_url: .html_url, head_sha: .head_sha, created_at: .created_at, run_attempt: .run_attempt}]';
 
 async function getRunsForCommit(repository, sha, run, warn) {
   if (!sha) return [];
@@ -87,7 +89,7 @@ async function getRunsForCommit(repository, sha, run, warn) {
 async function getRecentBranchRuns(repository, branch, run, warn) {
   if (!branch) return [];
   try {
-    const json = await commandOutput(run, 'gh', ['api', `repos/${repository.fullName}/actions/runs?branch=${encodeURIComponent(branch)}&per_page=20`, '--jq', RUNS_JQ]);
+    const json = await commandOutput(run, 'gh', ['api', `repos/${repository.fullName}/actions/runs?branch=${encodeURIComponent(branch)}&per_page=100`, '--jq', RUNS_JQ]);
     const parsed = JSON.parse(json);
     return Array.isArray(parsed) ? parsed : [];
   } catch (error) {
@@ -96,7 +98,7 @@ async function getRecentBranchRuns(repository, branch, run, warn) {
   }
 }
 
-export async function prepareCiCdIssue({ repository, run = runCommand, warn = message => console.warn(message) }) {
+export async function prepareCiCdIssue({ repository, run = runCommand, warn = message => console.warn(message), log = null }) {
   const [languages, defaultBranch] = await Promise.all([detectLanguages(repository, run, warn), getDefaultBranch(repository, run, warn)]);
   const commit = await getLatestCommit(repository, defaultBranch, run, warn);
   let runs = await getRunsForCommit(repository, commit?.sha, run, warn);
@@ -110,11 +112,22 @@ export async function prepareCiCdIssue({ repository, run = runCommand, warn = me
     }
   }
 
+  // The branch fallback returns every run of every workflow across many
+  // commits; the issue must list one row per workflow (issue #2125).
+  const fetchedRuns = runs.length;
+  runs = dedupeRunsByWorkflow(runs);
+  const duplicates = fetchedRuns - runs.length;
+  if (duplicates > 0 && typeof log === 'function') {
+    log(`ℹ️  Collapsed ${duplicates} older CI/CD run(s) — keeping the latest run of each workflow (${runs.length} workflow(s), source: ${runsSource}).`);
+  }
+
   return {
     repository,
     defaultBranch,
     commit,
     runs,
+    fetchedRuns,
+    duplicateRuns: duplicates,
     languages,
     runsSource,
     title: buildCiCdIssueTitle(),
@@ -123,7 +136,7 @@ export async function prepareCiCdIssue({ repository, run = runCommand, warn = me
 }
 
 export async function createCiCdIssue({ repository, prepared = null, run = runCommand, log = null, warn = message => console.warn(message) }) {
-  const issueDraft = prepared || (await prepareCiCdIssue({ repository, run, warn }));
+  const issueDraft = prepared || (await prepareCiCdIssue({ repository, run, warn, log }));
   const issue = await createTaskIssue({
     repository,
     title: issueDraft.title,

package/src/fix.ci-cd.lib.mjs

@@ -249,27 +249,95 @@ export function buildTemplatesSection(languages) {
   return lines.join('\n');
 }
 
-/** Render the CI/CD runs section from the GitHub Actions API payload. */
-export function buildRunsSection(runs, { emptyMessage } = {}) {
+/**
+ * Stable identity of the workflow a run belongs to (issue #2125).
+ *
+ * `workflow_id` is the authoritative key: two workflow files may share the same
+ * display `name`, and one workflow file may be renamed between runs. The name
+ * (and `path`) are only fallbacks for payloads that omit the id.
+ */
+export function runWorkflowKey(run) {
+  const workflowId = run?.workflow_id ?? run?.workflowId;
+  if (workflowId !== undefined && workflowId !== null && workflowId !== '') return `id:${workflowId}`;
+  if (run?.path) return `path:${run.path}`;
+  const name = run?.name || run?.workflowName;
+  // A run with no identity at all cannot be proven to be a duplicate.
+  return name ? `name:${String(name).toLowerCase()}` : null;
+}
+
+/** Recency of a run: newest first, using created_at, then attempt, then id. */
+function compareRunRecency(a, b) {
+  const timeA = Date.parse(a?.created_at || a?.run_started_at || '') || 0;
+  const timeB = Date.parse(b?.created_at || b?.run_started_at || '') || 0;
+  if (timeA !== timeB) return timeB - timeA;
+  const attemptA = Number(a?.run_attempt) || 0;
+  const attemptB = Number(b?.run_attempt) || 0;
+  if (attemptA !== attemptB) return attemptB - attemptA;
+  return (Number(b?.id) || 0) - (Number(a?.id) || 0);
+}
+
+/**
+ * Keep only the most recent run per workflow (issue #2125).
+ *
+ * When `/fix --ci-cd` falls back to "recent runs on the default branch" the
+ * GitHub API returns every run of every workflow across many commits, so the
+ * generated issue listed the same two workflows twenty times. One row per
+ * workflow — its latest run — is what makes the table actionable.
+ *
+ * Order of the surviving rows follows the input (the API returns newest first).
+ */
+export function dedupeRunsByWorkflow(runs) {
+  const list = Array.isArray(runs) ? runs : [];
+  const bestByWorkflow = new Map(); // key -> { run, index }
+  list.forEach((run, index) => {
+    const key = runWorkflowKey(run) ?? `index:${index}`;
+    const existing = bestByWorkflow.get(key);
+    if (!existing || compareRunRecency(run, existing.run) < 0) {
+      bestByWorkflow.set(key, { run, index: existing ? existing.index : index });
+    }
+  });
+  return [...bestByWorkflow.values()].sort((a, b) => a.index - b.index).map(entry => entry.run);
+}
+
+/** How many rows `dedupeRunsByWorkflow` would drop (for verbose logging). */
+export function countDuplicateRuns(runs) {
   const list = Array.isArray(runs) ? runs : [];
+  return list.length - dedupeRunsByWorkflow(list).length;
+}
+
+/**
+ * Render the CI/CD runs section from the GitHub Actions API payload.
+ *
+ * Runs are deduplicated per workflow (issue #2125). Pass `includeCommit: true`
+ * when the rows may come from different commits (the default-branch fallback)
+ * so it stays visible which commit each run belongs to.
+ */
+export function buildRunsSection(runs, { emptyMessage, includeCommit = false } = {}) {
+  const list = dedupeRunsByWorkflow(runs);
   if (list.length === 0) {
     return emptyMessage || 'No CI/CD runs were found for the latest default-branch commit.';
   }
-  const header = '| Workflow | Status | Conclusion | Run |\n| --- | --- | --- | --- |';
+  const header = includeCommit ? '| Workflow | Status | Conclusion | Commit | Run |\n| --- | --- | --- | --- | --- |' : '| Workflow | Status | Conclusion | Run |\n| --- | --- | --- | --- |';
   const rows = list.map(run => {
     const name = run.name || run.workflowName || 'unknown';
     const status = run.status || 'unknown';
     const conclusion = run.conclusion || (status === 'completed' ? 'unknown' : 'in_progress');
     const url = run.html_url || run.url || '';
     const runLabel = url ? `[run](${url})` : '—';
-    return `| ${name} | ${status} | ${conclusion} | ${runLabel} |`;
+    if (!includeCommit) return `| ${name} | ${status} | ${conclusion} | ${runLabel} |`;
+    const sha = shortSha(run.head_sha);
+    return `| ${name} | ${status} | ${conclusion} | ${sha ? `\`${sha}\`` : '—'} | ${runLabel} |`;
   });
   return [header, ...rows].join('\n');
 }
 
-/** Count the runs that did not pass (failure/cancelled/timed_out/etc.). */
+/**
+ * Count the runs that did not pass (failure/cancelled/timed_out/etc.).
+ * Counts one run per workflow so the summary matches the rendered table
+ * (issue #2125).
+ */
 export function summarizeRunFailures(runs) {
-  const list = Array.isArray(runs) ? runs : [];
+  const list = dedupeRunsByWorkflow(runs);
   const passing = new Set(['success', 'neutral', 'skipped']);
   const failing = list.filter(run => {
     const conclusion = (run.conclusion || '').toLowerCase();
@@ -375,7 +443,10 @@ export const CI_CD_ISSUE_LABELS = Object.freeze(['bug']);
  */
 export function buildCiCdIssueBody({ repository, defaultBranch, commit, runs, languages, runsSource = 'commit', omittedOptions = FIX_FORWARDED_SOLVE_OPTIONS }) {
   const { sortedTemplates } = mapLanguagesToTemplates(languages);
-  const { total, failing } = summarizeRunFailures(runs);
+  // One row per workflow: the branch fallback returns every run of every
+  // workflow across many commits (issue #2125).
+  const uniqueRuns = dedupeRunsByWorkflow(runs);
+  const { total, failing } = summarizeRunFailures(uniqueRuns);
 
   const commitLine = commit?.sha ? `\`${shortSha(commit.sha)}\`${commit.url ? ` ([commit](${commit.url}))` : ''}${commit.message ? ` — ${String(commit.message).split('\n')[0]}` : ''}` : 'unknown';
 
@@ -385,7 +456,7 @@ export function buildCiCdIssueBody({ repository, defaultBranch, commit, runs, la
   const runsHeading = runsSource === 'branch' ? `Recent CI/CD runs on \`${defaultBranch || 'default branch'}\`` : 'Latest default-branch CI/CD runs';
   const runsEmptyMessage = runsSource === 'branch' ? `No recent CI/CD runs were found on \`${defaultBranch || 'the default branch'}\`.` : 'No CI/CD runs were found for the latest default-branch commit.';
 
-  const sections = [`### ${runsHeading}`, '', buildRunsSection(runs, { emptyMessage: runsEmptyMessage }), '', buildStandardPrompt({ templatesSorted: sortedTemplates, omittedOptions }), '', '---', '', '<details>', '<summary>Context collected by <code>/fix --ci-cd</code></summary>', '', `- **Repository:** [${repository?.fullName}](${repository?.url})`, `- **Default branch:** \`${defaultBranch || 'unknown'}\``, `- **Latest commit:** ${commitLine}`, `- **CI/CD runs found:** ${total} (${failing} not passing)`, '', '**Detected languages**', '', buildLanguagesSection(languages), '', '**Recommended CI/CD templates**', '', buildTemplatesSection(languages), '', '</details>'];
+  const sections = [`### ${runsHeading}`, '', buildRunsSection(uniqueRuns, { emptyMessage: runsEmptyMessage, includeCommit: runsSource === 'branch' }), '', buildStandardPrompt({ templatesSorted: sortedTemplates, omittedOptions }), '', '---', '', '<details>', '<summary>Context collected by <code>/fix --ci-cd</code></summary>', '', `- **Repository:** [${repository?.fullName}](${repository?.url})`, `- **Default branch:** \`${defaultBranch || 'unknown'}\``, `- **Latest commit:** ${commitLine}`, `- **CI/CD runs found:** ${total} (${failing} not passing)`, '', '**Detected languages**', '', buildLanguagesSection(languages), '', '**Recommended CI/CD templates**', '', buildTemplatesSection(languages), '', '</details>'];
 
   return sections.join('\n');
 }

package/src/fix.mjs

@@ -83,7 +83,7 @@ async function main() {
   const repository = parsed.repository;
   console.log(`🔧 /fix --ci-cd for ${repository.fullName}`);
 
-  const prepared = await prepareCiCdIssue({ repository });
+  const prepared = await prepareCiCdIssue({ repository, log: message => console.log(`   ${message}`) });
   const { defaultBranch, commit, runs, runsSource, title, body } = prepared;
 
   const { total, failing } = summarizeRunFailures(runs);

package/src/pr-draft-state.lib.mjs

@@ -0,0 +1,137 @@
+/**
+ * Single source of truth for pull request draft/ready state transitions.
+ *
+ * Issue #2123: every place that starts, restarts or resumes a working session must
+ * put the pull request back into draft mode (if it is not already a draft), and every
+ * place that ends a working session must convert it back to ready for review.
+ *
+ * Before this module the logic was duplicated inline in solve.session.lib.mjs and was
+ * gated behind `argv.watch || argv.autoContinue`, so auto-restart / auto-resume
+ * sessions (temporary watch mode, auto-restart-until-mergeable, escalate,
+ * keep-working, auto-ensure, PR-placeholder restart) kept the PR marked as
+ * "ready for review" while the AI was actively working on it.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2123
+ */
+
+// rate-limit marker (#1726): callers pass in a `$` already wrapped by wrapDollarWithGhRetry.
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs';
+
+const noopLog = async () => {};
+
+/**
+ * Fetch the draft/open state of a pull request.
+ *
+ * @param {Object} options
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {number|string} options.prNumber - Pull request number
+ * @param {Function} options.$ - command-stream style tagged template executor
+ * @param {Function} [options.log] - Logger
+ * @returns {Promise<{ok: boolean, isDraft: (boolean|null), state: (string|null), merged: boolean, error: (string|null)}>}
+ */
+export const getPullRequestDraftState = async ({ owner, repo, prNumber, $, log = noopLog }) => {
+  try {
+    const result = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json isDraft,state`;
+    if (result.code !== 0) {
+      const stderr = result.stderr ? result.stderr.toString().trim() : '';
+      return { ok: false, isDraft: null, state: null, merged: false, error: stderr || `gh exited with code ${result.code}` };
+    }
+
+    const raw = result.stdout.toString().trim();
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return { ok: false, isDraft: null, state: null, merged: false, error: `Could not parse gh output: ${raw.slice(0, 200)}` };
+    }
+
+    const state = typeof parsed.state === 'string' ? parsed.state.toUpperCase() : null;
+    await log(`   🔍 PR #${prNumber} draft state: isDraft=${parsed.isDraft}, state=${state}`, { verbose: true });
+
+    return { ok: true, isDraft: parsed.isDraft === true, state, merged: state === 'MERGED', error: null };
+  } catch (error) {
+    return { ok: false, isDraft: null, state: null, merged: false, error: error.message };
+  }
+};
+
+/**
+ * Internal helper shared by ensurePullRequestIsDraft/ensurePullRequestIsReady.
+ *
+ * @param {Object} options
+ * @param {'draft'|'ready'} options.target - Desired state
+ * @returns {Promise<{ok: boolean, changed: boolean, skipped: boolean, reason: (string|null), error: (string|null)}>}
+ */
+const setPullRequestDraftState = async ({ target, owner, repo, prNumber, $, log = noopLog, formatAligned = null, indent = 2, reason = null, reportError = null }) => {
+  const wantDraft = target === 'draft';
+  const label = wantDraft ? 'draft mode' : 'ready for review';
+  const write = async (icon, key, value) => {
+    await log(formatAligned ? formatAligned(icon, key, value, indent) : `${icon} ${key} ${value}`);
+  };
+
+  if (!owner || !repo || !prNumber) {
+    return { ok: false, changed: false, skipped: true, reason: 'missing_pr_context', error: null };
+  }
+
+  try {
+    const status = await getPullRequestDraftState({ owner, repo, prNumber, $, log });
+
+    if (!status.ok) {
+      await log(`Warning: Could not check PR #${prNumber} draft status: ${status.error}`, { level: 'warning' });
+      return { ok: false, changed: false, skipped: false, reason: 'status_check_failed', error: status.error };
+    }
+
+    // A merged or closed pull request cannot change its draft state; GitHub rejects it.
+    if (status.state && status.state !== 'OPEN') {
+      await write('ℹ️', 'PR status:', `${status.state.toLowerCase()} - skipping ${label} conversion`);
+      return { ok: true, changed: false, skipped: true, reason: `pr_${status.state.toLowerCase()}`, error: null };
+    }
+
+    if (status.isDraft === wantDraft) {
+      await write('✅', 'PR status:', `Already in ${label}`);
+      return { ok: true, changed: false, skipped: true, reason: 'already_in_target_state', error: null };
+    }
+
+    await write('📝', 'Converting PR:', `To ${label}${reason ? ` (${reason})` : ''}...`);
+    const convertResult = wantDraft ? await $`gh pr ready ${prNumber} --repo ${owner}/${repo} --undo` : await $`gh pr ready ${prNumber} --repo ${owner}/${repo}`;
+
+    if (convertResult.code === 0) {
+      await write('✅', 'PR converted:', `Now in ${label}`);
+      return { ok: true, changed: true, skipped: false, reason: null, error: null };
+    }
+
+    const stderr = convertResult.stderr ? convertResult.stderr.toString().trim() : '';
+    await log(`Warning: Could not convert PR #${prNumber} to ${label}${stderr ? `: ${stderr}` : ''}`, { level: 'warning' });
+    return { ok: false, changed: false, skipped: false, reason: 'conversion_failed', error: stderr || `gh exited with code ${convertResult.code}` };
+  } catch (error) {
+    if (typeof reportError === 'function') {
+      reportError(error, {
+        context: wantDraft ? 'convert_pr_to_draft' : 'convert_pr_to_ready',
+        prNumber,
+        owner,
+        repo,
+        operation: 'pr_status_change',
+      });
+    }
+    await log(`Warning: Could not check/convert PR #${prNumber} draft status: ${error.message}`, { level: 'warning' });
+    return { ok: false, changed: false, skipped: false, reason: 'exception', error: error.message };
+  }
+};
+
+/**
+ * Put a pull request into draft mode when a working session starts/restarts/resumes.
+ * No-op when the PR is already a draft, merged, or closed.
+ */
+export const ensurePullRequestIsDraft = async options => setPullRequestDraftState({ ...options, target: 'draft' });
+
+/**
+ * Put a pull request back to "ready for review" when a working session ends.
+ * No-op when the PR is already ready, merged, or closed.
+ */
+export const ensurePullRequestIsReady = async options => setPullRequestDraftState({ ...options, target: 'ready' });
+
+export default {
+  getPullRequestDraftState,
+  ensurePullRequestIsDraft,
+  ensurePullRequestIsReady,
+};

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

@@ -162,6 +162,14 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
       await log(`🔄 Session will be RESTARTED (fresh start without previous context)`);
     }
 
+    // Issue #2123: the resumed/restarted process is launched with the ISSUE url, so without
+    // --auto-continue it would not enter continue mode, would not find the existing PR, and
+    // therefore would never convert that PR back to draft (nor post the auto-resume/auto-restart
+    // session comment). Preserve the flag so the new session attaches to the same PR.
+    if (argv.autoContinue) {
+      resumeArgs.push('--auto-continue');
+    }
+
     // Preserve auto-resume/auto-restart flag for subsequent limit hits
     if (argv.autoResumeOnLimitReset) {
       resumeArgs.push('--auto-resume-on-limit-reset');

package/src/solve.restart-shared.lib.mjs

@@ -33,6 +33,8 @@ const lib = await import('./lib.mjs');
 const { log, formatAligned, extractToolErrorCore } = lib;
 const { ensurePullRequestBaseBranch } = await import('./solve.pr-base-guard.lib.mjs');
 const { RESOURCE_PHASE_RESTART_AFTER, RESOURCE_PHASE_RESTART_BEFORE, recordResourceSnapshot } = await import('./solve.resource-diagnostics.lib.mjs');
+// Issue #2123: shared draft/ready transitions for working sessions.
+const { ensurePullRequestIsDraft } = await import('./pr-draft-state.lib.mjs');
 
 // Import Sentry integration
 const sentryLib = await import('./sentry.lib.mjs');
@@ -185,6 +187,23 @@ export const executeToolIteration = async params => {
     label: 'before AI restart iteration',
   });
 
+  // Issue #2123: every restart/resume iteration is a new working session, so the PR must be
+  // put back into draft before the AI starts changing it. This single call covers watch mode,
+  // temporary auto-restart, auto-restart-until-mergeable, escalate, keep-working,
+  // auto-ensure-requirements and the PR-placeholder restart, which all funnel through here.
+  if (prNumber) {
+    await ensurePullRequestIsDraft({
+      owner,
+      repo,
+      prNumber,
+      $,
+      log,
+      formatAligned,
+      reason: 'restart iteration',
+      reportError,
+    });
+  }
+
   // Import necessary modules for tool execution
   const memoryCheck = await import('./memory-check.mjs');
   const { getResourceSnapshot } = memoryCheck;

package/src/solve.session.lib.mjs

@@ -9,6 +9,10 @@
 import { AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, postTrackedComment } from './tool-comments.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+
+// Issue #2123: draft/ready transitions live in one shared module so every session
+// start/restart/resume path behaves identically.
+import { ensurePullRequestIsDraft, ensurePullRequestIsReady } from './pr-draft-state.lib.mjs';
 /**
  * Session type definitions for different work session contexts
  * See: https://github.com/link-assistant/hive-mind/issues/1152
@@ -70,39 +74,30 @@ function getSessionCommentContent(sessionType, timestamp) {
  * @param {string} [options.sessionType='new'] - One of SESSION_TYPES values
  */
 export async function startWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $, sessionType = SESSION_TYPES.NEW }) {
-  // Record work start time and convert PR to draft if in continue/watch mode
+  // Record work start time and convert PR to draft.
+  //
+  // Issue #2123: the draft conversion used to be gated behind `argv.watch || argv.autoContinue`,
+  // so plain `--resume`/continue-mode sessions left the PR marked "ready for review" while the
+  // AI was still working on it. Any continue-mode session with a PR now converts it to draft.
   const workStartTime = new Date();
-  if (isContinueMode && prNumber && (argv.watch || argv.autoContinue)) {
+  const shouldPostSessionComment = argv.watch || argv.autoContinue;
+  if (isContinueMode && prNumber) {
     await log(`\n${formatAligned('🚀', 'Starting work session:', workStartTime.toISOString())}`);
 
-    // Convert PR back to draft if not already
-    try {
-      const prStatusResult = await $`gh pr view ${prNumber} --repo ${global.owner}/${global.repo} --json isDraft --jq .isDraft`;
-      if (prStatusResult.code === 0) {
-        const isDraft = prStatusResult.stdout.toString().trim() === 'true';
-        if (!isDraft) {
-          await log(formatAligned('📝', 'Converting PR:', 'Back to draft mode...', 2));
-          const convertResult = await $`gh pr ready ${prNumber} --repo ${global.owner}/${global.repo} --undo`;
-          if (convertResult.code === 0) {
-            await log(formatAligned('✅', 'PR converted:', 'Now in draft mode', 2));
-          } else {
-            await log('Warning: Could not convert PR to draft', { level: 'warning' });
-          }
-        } else {
-          await log(formatAligned('✅', 'PR status:', 'Already in draft mode', 2));
-        }
-      }
-    } catch (error) {
-      const sentryLib = await import('./sentry.lib.mjs');
-      const { reportError } = sentryLib;
-      reportError(error, {
-        context: 'convert_pr_to_draft',
-        prNumber,
-        operation: 'pr_status_change',
-      });
-      await log('Warning: Could not check/convert PR draft status', { level: 'warning' });
-    }
+    const { reportError } = await import('./sentry.lib.mjs');
+    await ensurePullRequestIsDraft({
+      owner: global.owner,
+      repo: global.repo,
+      prNumber,
+      $,
+      log,
+      formatAligned,
+      reason: `session start: ${sessionType}`,
+      reportError,
+    });
+  }
 
+  if (isContinueMode && prNumber && shouldPostSessionComment) {
     // Post a comment marking the start of work session with appropriate header based on session type.
     // Issue #1625: Use postTrackedComment so the comment ID is registered in-memory and can be
     // excluded from the "did the AI post anything?" check in checkForAiCreatedComments().
@@ -131,14 +126,17 @@ export async function startWorkSession({ isContinueMode, prNumber, argv, log, fo
 }
 
 export async function endWorkSession({ isContinueMode, prNumber, argv, log, formatAligned, $, logsAttached = false }) {
-  // Post end work session comment and convert PR back to ready if in continue mode
-  if (isContinueMode && prNumber && (argv.watch || argv.autoContinue)) {
+  // Post end work session comment and convert PR back to ready if in continue mode.
+  // Issue #2123: the ready conversion mirrors startWorkSession's draft conversion, so it must
+  // run for every continue-mode session, not only for --watch/--auto-continue ones.
+  if (isContinueMode && prNumber) {
     const workEndTime = new Date();
+    const shouldPostSessionComment = argv.watch || argv.autoContinue;
     await log(`\n${formatAligned('🏁', 'Ending work session:', workEndTime.toISOString())}`);
 
     // Only post end comment if logs were NOT already attached
     // The attachLogToGitHub comment already serves as finishing status with "Now working session is ended" text
-    if (!logsAttached) {
+    if (shouldPostSessionComment && !logsAttached) {
       // Post a comment marking the end of work session.
       // Issue #1625: Track the comment ID so it won't be mistaken for AI-authored content.
       try {
@@ -159,36 +157,21 @@ export async function endWorkSession({ isContinueMode, prNumber, argv, log, form
         });
         await log('Warning: Could not post work end comment', { level: 'warning' });
       }
-    } else {
+    } else if (shouldPostSessionComment) {
       await log(formatAligned('ℹ️', 'Skipping:', 'End comment (logs already attached with session end message)', 2));
     }
 
-    // Convert PR back to ready for review
-    try {
-      const prStatusResult = await $`gh pr view ${prNumber} --repo ${global.owner}/${global.repo} --json isDraft --jq .isDraft`;
-      if (prStatusResult.code === 0) {
-        const isDraft = prStatusResult.stdout.toString().trim() === 'true';
-        if (isDraft) {
-          await log(formatAligned('🔀', 'Converting PR:', 'Back to ready for review...', 2));
-          const convertResult = await $`gh pr ready ${prNumber} --repo ${global.owner}/${global.repo}`;
-          if (convertResult.code === 0) {
-            await log(formatAligned('✅', 'PR converted:', 'Ready for review', 2));
-          } else {
-            await log('Warning: Could not convert PR to ready', { level: 'warning' });
-          }
-        } else {
-          await log(formatAligned('✅', 'PR status:', 'Already ready for review', 2));
-        }
-      }
-    } catch (error) {
-      const sentryLib = await import('./sentry.lib.mjs');
-      const { reportError } = sentryLib;
-      reportError(error, {
-        context: 'convert_pr_to_ready',
-        prNumber,
-        operation: 'pr_status_change',
-      });
-      await log('Warning: Could not convert PR to ready status', { level: 'warning' });
-    }
+    // Convert PR back to ready for review (issue #2123: shared implementation)
+    const { reportError } = await import('./sentry.lib.mjs');
+    await ensurePullRequestIsReady({
+      owner: global.owner,
+      repo: global.repo,
+      prNumber,
+      $,
+      log,
+      formatAligned,
+      reason: 'session end',
+      reportError,
+    });
   }
 }