@link-assistant/hive-mind 2.11.0 → 2.11.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 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.1",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

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