@link-assistant/hive-mind 1.54.7 → 1.55.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.55.0
+
+### Minor Changes
+
+- d696423: Add experimental bidirectional interactive mode (issue #817). Introduces three composable opt-in flags for `solve` (auto-forwarded to `hive`): `--accept-incomming-comments-as-input` (feed new PR/issue comments into Claude as stream-json input, excluding solve's own system comments), `--exclude-all-own-incomming-comments-from-input` (also skip comments authored by the same GitHub user that solve runs as), and `--bidirectional-interactive-mode` (composite convenience flag that enables `--interactive-mode` plus the two flags above). All flags default off and only take effect with `--tool claude`.
+
+## 1.54.8
+
+### Patch Changes
+
+- 12f5761: Fix `--auto-restart-until-mergeable` readiness comment deduplication for pull requests with more than one page of comments, and enforce pagination on list-returning `gh api` calls.
+
 ## 1.54.7
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.54.7",
+  "version": "1.55.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -14,12 +14,12 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",
-    "lint": "eslint 'src/**/*.{js,mjs,cjs}'",
-    "lint:fix": "eslint 'src/**/*.{js,mjs,cjs}' --fix",
+    "lint": "eslint 'src/**/*.{js,mjs,cjs}' 'scripts/**/*.{js,mjs,cjs}' 'eslint-rules/**/*.{js,mjs,cjs}'",
+    "lint:fix": "eslint 'src/**/*.{js,mjs,cjs}' 'scripts/**/*.{js,mjs,cjs}' 'eslint-rules/**/*.{js,mjs,cjs}' --fix",
     "check:duplication": "jscpd .",
     "format": "prettier --write \"**/*.{js,mjs,json,md}\" --ignore-path .prettierignore",
     "format:check": "prettier --check \"**/*.{js,mjs,json,md}\" --ignore-path .prettierignore",

package/src/bidirectional-interactive.lib.mjs

@@ -0,0 +1,710 @@
+#!/usr/bin/env node
+/**
+ * Bidirectional Interactive Mode Library
+ *
+ * [EXPERIMENTAL] This module provides bidirectional real-time communication during Claude execution.
+ * It monitors PR comments for user feedback and queues it for injection into the running Claude session.
+ *
+ * Key features:
+ * - Monitors GitHub PR comments for new user feedback
+ * - Queues feedback messages for injection into Claude's stdin
+ * - Works with Claude CLI's --input-format stream-json mode
+ * - Filters out system-generated comments (from interactive mode itself)
+ *
+ * Usage:
+ *   const { createBidirectionalHandler } = await import('./bidirectional-interactive.lib.mjs');
+ *   const handler = createBidirectionalHandler({ owner, repo, prNumber, $ });
+ *   await handler.startMonitoring();
+ *   // Later...
+ *   const feedback = handler.getQueuedFeedback();
+ *
+ * @module bidirectional-interactive.lib.mjs
+ * @experimental
+ */
+
+// Configuration constants
+const CONFIG = {
+  // Minimum time between comment checks to avoid rate limiting (in ms)
+  MIN_POLL_INTERVAL: 10000,
+  // Default poll interval (in ms)
+  DEFAULT_POLL_INTERVAL: 15000,
+  // Maximum queued feedback messages
+  MAX_QUEUE_SIZE: 50,
+  // Default keep-alive for the headless Claude process between stream-json
+  // turns. Claude Code exits after this many ms with no new input once it
+  // has replied, so new PR comments have a window to flow in as additional
+  // user messages. Issue #817.
+  DEFAULT_EXIT_AFTER_STOP_DELAY_MS: 60_000,
+  // Signature to identify system-generated comments
+  SYSTEM_COMMENT_SIGNATURES: ['## 🚀 Session Started', '## 💬 Assistant Response', '## 💻 Tool: ', '## 📝 Tool: ', '## 📖 Tool: ', '## ✏️ Tool: ', '## 🔍 Tool: ', '## 🔎 Tool: ', '## 🌐 Tool: ', '## 📋 Tool: ', '## 🎯 Tool: ', '## 📓 Tool: ', '## 🔧 Tool: ', '## ✅ Tool Result:', '## ❌ Tool Result:', '## ✅ Session Complete', '## ❌ Session Failed', '## ❓ Unrecognized Event:', '📄 Raw JSON', '🤖 Generated with [Claude Code]', '🤖 AI-Powered Solution Draft', '*This PR was created automatically by the AI issue solver*'],
+};
+
+/**
+ * Check if a comment body is system-generated (from interactive mode)
+ *
+ * @param {string} body - Comment body to check
+ * @returns {boolean} True if the comment is system-generated
+ */
+const isSystemComment = body => {
+  if (!body || typeof body !== 'string') {
+    return false;
+  }
+  return CONFIG.SYSTEM_COMMENT_SIGNATURES.some(sig => body.includes(sig));
+};
+
+/**
+ * Format a user feedback message for Claude CLI's stream-json input
+ *
+ * @param {string} feedbackText - The user's feedback text
+ * @returns {string} JSON string ready to write to Claude's stdin
+ */
+const formatFeedbackForClaude = feedbackText => {
+  const message = {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: [
+        {
+          type: 'text',
+          text: `[USER FEEDBACK FROM PR COMMENT]\n\n${feedbackText}\n\n[END OF USER FEEDBACK - Please address this feedback in your current work]`,
+        },
+      ],
+    },
+  };
+  return JSON.stringify(message);
+};
+
+/**
+ * Build the first stream-json user frame for a Claude Code headless session.
+ *
+ * Issue #817: When --accept-incomming-comments-as-input is enabled, solve
+ * spawns Claude with `--input-format stream-json` and a pipe stdin. The
+ * initial user prompt must therefore be delivered as a NDJSON frame rather
+ * than via `-p`. This matches the pattern from the reference gist
+ * `claude-stream-persistent.mjs`.
+ *
+ * @param {string} promptText - The initial user prompt
+ * @param {Object} [options]
+ * @param {string} [options.sessionId] - Optional session_id to stamp on the frame
+ * @returns {string} NDJSON-ready JSON string (no trailing newline)
+ */
+const buildInitialUserFrame = (promptText, options = {}) => {
+  const frame = {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: [{ type: 'text', text: String(promptText ?? '') }],
+    },
+    parent_tool_use_id: null,
+  };
+  if (options.sessionId) frame.session_id = options.sessionId;
+  return JSON.stringify(frame);
+};
+
+/**
+ * Write one NDJSON frame into a live Claude stdin stream.
+ *
+ * Returns true on a successful write, false when the stream is missing or
+ * closed. Never throws — callers just log and continue. Internal helper used
+ * by both the comment-polling loop and `streamInitialPrompt`.
+ *
+ * @param {Object} stream - A writable stream (child.stdin)
+ * @param {string} jsonFrame - A single JSON frame (no trailing newline)
+ * @param {Function} [logFn] - Optional logger
+ * @param {boolean} [verbose=false]
+ * @returns {Promise<boolean>}
+ * @private
+ */
+const writeFrameToStdin = async (stream, jsonFrame, logFn, verbose = false) => {
+  if (!stream || typeof stream.write !== 'function') return false;
+  if (stream.destroyed || stream.writableEnded || stream.closed) return false;
+  try {
+    stream.write(`${jsonFrame}\n`);
+    return true;
+  } catch (err) {
+    if (logFn && verbose) {
+      try {
+        await logFn(`⚠️ Bidirectional mode: Failed to write to Claude stdin: ${err.message}`, { verbose: true });
+      } catch {
+        /* ignore logger errors */
+      }
+    }
+    return false;
+  }
+};
+
+/**
+ * Creates a bidirectional interactive mode handler
+ *
+ * @param {Object} options - Handler configuration
+ * @param {string} options.owner - Repository owner
+ * @param {string} options.repo - Repository name
+ * @param {number} options.prNumber - Pull request number
+ * @param {Function} options.$ - command-stream $ function
+ * @param {Function} options.log - Logging function
+ * @param {boolean} [options.verbose=false] - Enable verbose logging
+ * @param {number} [options.pollInterval=15000] - Interval between comment checks (ms)
+ * @param {boolean} [options.excludeOwnComments=false] - Exclude comments authored by the same GitHub user that solve runs as (prevents "talking to yourself")
+ * @returns {Object} Handler object with monitoring methods
+ */
+export const createBidirectionalHandler = options => {
+  const { owner, repo, prNumber, $, log, verbose = false, pollInterval = CONFIG.DEFAULT_POLL_INTERVAL, excludeOwnComments = false } = options;
+  // Resolved lazily on first check, cached for the lifetime of the handler
+  let ownUserLogin = null;
+  let ownUserResolved = false;
+  const resolveOwnUserLogin = async () => {
+    if (ownUserResolved) return ownUserLogin;
+    try {
+      const result = await $`gh api user --jq .login`;
+      ownUserLogin = (result.stdout?.toString() || '').trim() || null;
+    } catch (error) {
+      if (verbose) {
+        await log(`⚠️ Bidirectional mode: Could not resolve current gh user: ${error.message}`, { verbose: true });
+      }
+      ownUserLogin = null;
+    }
+    ownUserResolved = true;
+    return ownUserLogin;
+  };
+
+  // State tracking for the handler
+  const state = {
+    isMonitoring: false,
+    lastCheckedCommentId: null,
+    lastCheckedTimestamp: null,
+    feedbackQueue: [],
+    pollIntervalId: null,
+    processedCommentIds: new Set(),
+    totalCommentsProcessed: 0,
+    totalFeedbackQueued: 0,
+    // Issue #817: Writable stdin of the live Claude process. When set, new
+    // non-system comments are written directly as NDJSON frames rather than
+    // only accumulated in feedbackQueue.
+    claudeStdin: null,
+    totalFeedbackStreamed: 0,
+  };
+
+  /**
+   * Fetch recent comments from the PR
+   * @returns {Promise<Array>} Array of comment objects
+   * @private
+   */
+  const fetchRecentComments = async () => {
+    if (!prNumber || !owner || !repo) {
+      if (verbose) {
+        await log('⚠️ Bidirectional mode: Cannot fetch comments - missing PR info', { verbose: true });
+      }
+      return [];
+    }
+
+    try {
+      // Fetch comments using gh api with pagination (GitHub defaults to 30/page), sorted by created_at desc
+      const result = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate --jq '[.[] | {id: .id, body: .body, created_at: .created_at, user: .user.login}] | sort_by(.created_at) | reverse'`;
+      const comments = JSON.parse(result.stdout.toString());
+      return comments;
+    } catch (error) {
+      if (verbose) {
+        await log(`⚠️ Bidirectional mode: Failed to fetch comments: ${error.message}`, { verbose: true });
+      }
+      return [];
+    }
+  };
+
+  /**
+   * Check for new user comments and queue them as feedback
+   * @private
+   */
+  const checkForNewComments = async () => {
+    if (!state.isMonitoring) {
+      return;
+    }
+
+    try {
+      const comments = await fetchRecentComments();
+
+      if (comments.length === 0) {
+        return;
+      }
+
+      // Resolve current user login once if we need to exclude own comments
+      const ownLogin = excludeOwnComments ? await resolveOwnUserLogin() : null;
+
+      // Filter for new comments we haven't processed yet
+      for (const comment of comments) {
+        // Skip if already processed
+        if (state.processedCommentIds.has(comment.id)) {
+          continue;
+        }
+
+        // Skip if this is a system-generated comment (comments generated by our own solve command)
+        if (isSystemComment(comment.body)) {
+          state.processedCommentIds.add(comment.id);
+          continue;
+        }
+
+        // Issue #817: Optionally skip comments authored by the same GitHub user that solve runs as
+        if (excludeOwnComments && ownLogin && comment.user === ownLogin) {
+          if (verbose) {
+            await log(`⏭️ Bidirectional mode: Skipping comment #${comment.id} from own user @${ownLogin} (--exclude-all-own-incomming-comments-from-input)`, { verbose: true });
+          }
+          state.processedCommentIds.add(comment.id);
+          continue;
+        }
+
+        // This is a new user comment - queue it as feedback
+        if (state.feedbackQueue.length < CONFIG.MAX_QUEUE_SIZE) {
+          const formattedMessage = formatFeedbackForClaude(comment.body);
+          state.feedbackQueue.push({
+            id: comment.id,
+            body: comment.body,
+            user: comment.user,
+            created_at: comment.created_at,
+            formattedMessage,
+          });
+          state.totalFeedbackQueued++;
+
+          if (verbose) {
+            await log(`📥 Bidirectional mode: Queued feedback from @${comment.user} (comment #${comment.id})`, { verbose: true });
+          }
+
+          // Issue #817: If we have a live Claude stdin attached, stream the
+          // comment as an NDJSON frame right now so Claude can pick it up on
+          // the next turn. This is the core of "real JSON streaming input"
+          // requested in the issue and the reference gist.
+          if (state.claudeStdin) {
+            const streamed = await writeFrameToStdin(state.claudeStdin, formattedMessage, log, verbose);
+            if (streamed) {
+              state.totalFeedbackStreamed++;
+              if (verbose) {
+                await log(`📤 Bidirectional mode: Streamed feedback from @${comment.user} (comment #${comment.id}) into Claude stdin`, { verbose: true });
+              }
+            }
+          }
+        } else {
+          if (verbose) {
+            await log(`⚠️ Bidirectional mode: Feedback queue full, skipping comment #${comment.id}`, { verbose: true });
+          }
+        }
+
+        state.processedCommentIds.add(comment.id);
+        state.totalCommentsProcessed++;
+      }
+    } catch (error) {
+      if (verbose) {
+        await log(`⚠️ Bidirectional mode: Error checking comments: ${error.message}`, { verbose: true });
+      }
+    }
+  };
+
+  /**
+   * Start monitoring PR comments for user feedback
+   *
+   * @returns {Promise<void>}
+   */
+  const startMonitoring = async () => {
+    if (state.isMonitoring) {
+      if (verbose) {
+        await log('ℹ️ Bidirectional mode: Already monitoring', { verbose: true });
+      }
+      return;
+    }
+
+    if (!prNumber || !owner || !repo) {
+      if (verbose) {
+        await log('⚠️ Bidirectional mode: Cannot start monitoring - missing PR info', { verbose: true });
+      }
+      return;
+    }
+
+    state.isMonitoring = true;
+
+    // Do initial check
+    await checkForNewComments();
+
+    // Set up polling interval
+    const interval = Math.max(pollInterval, CONFIG.MIN_POLL_INTERVAL);
+    state.pollIntervalId = setInterval(async () => {
+      await checkForNewComments();
+    }, interval);
+
+    if (verbose) {
+      await log(`🔌 Bidirectional mode: Started monitoring PR #${prNumber} (polling every ${interval / 1000}s)`, { verbose: true });
+    }
+  };
+
+  /**
+   * Stop monitoring PR comments
+   *
+   * @returns {Promise<void>}
+   */
+  const stopMonitoring = async () => {
+    if (!state.isMonitoring) {
+      return;
+    }
+
+    state.isMonitoring = false;
+
+    if (state.pollIntervalId) {
+      clearInterval(state.pollIntervalId);
+      state.pollIntervalId = null;
+    }
+
+    if (verbose) {
+      await log(`🔌 Bidirectional mode: Stopped monitoring (processed ${state.totalCommentsProcessed} comments, queued ${state.totalFeedbackQueued} feedback)`, { verbose: true });
+    }
+  };
+
+  /**
+   * Get next queued feedback message (FIFO)
+   * Does not remove from queue - use acknowledgeFeedback() after processing
+   *
+   * @returns {Object|null} Next feedback object or null if queue is empty
+   */
+  const peekFeedback = () => {
+    if (state.feedbackQueue.length === 0) {
+      return null;
+    }
+    return state.feedbackQueue[0];
+  };
+
+  /**
+   * Get and remove next queued feedback message (FIFO)
+   *
+   * @returns {Object|null} Next feedback object or null if queue is empty
+   */
+  const popFeedback = () => {
+    if (state.feedbackQueue.length === 0) {
+      return null;
+    }
+    return state.feedbackQueue.shift();
+  };
+
+  /**
+   * Get all queued feedback messages without removing them
+   *
+   * @returns {Array} Array of queued feedback objects
+   */
+  const getAllQueuedFeedback = () => {
+    return [...state.feedbackQueue];
+  };
+
+  /**
+   * Check if there is any queued feedback
+   *
+   * @returns {boolean} True if there is queued feedback
+   */
+  const hasFeedback = () => {
+    return state.feedbackQueue.length > 0;
+  };
+
+  /**
+   * Get the count of queued feedback messages
+   *
+   * @returns {number} Number of queued feedback messages
+   */
+  const getFeedbackCount = () => {
+    return state.feedbackQueue.length;
+  };
+
+  /**
+   * Clear all queued feedback
+   */
+  const clearFeedbackQueue = () => {
+    state.feedbackQueue = [];
+  };
+
+  /**
+   * Mark a specific comment ID as already processed
+   * Useful for filtering out comments that existed before monitoring started
+   *
+   * @param {number} commentId - Comment ID to mark as processed
+   */
+  const markCommentAsProcessed = commentId => {
+    state.processedCommentIds.add(commentId);
+  };
+
+  /**
+   * Initialize with existing comment IDs to skip
+   * Call this before startMonitoring() to avoid processing old comments
+   *
+   * @param {Array<number>} commentIds - Array of comment IDs to skip
+   */
+  const initializeWithExistingComments = commentIds => {
+    for (const id of commentIds) {
+      state.processedCommentIds.add(id);
+    }
+  };
+
+  /**
+   * Fetch and mark all existing comments as processed
+   * Call this before startMonitoring() to only get new comments
+   *
+   * @returns {Promise<number>} Number of existing comments marked
+   */
+  const initializeFromCurrentComments = async () => {
+    const comments = await fetchRecentComments();
+    for (const comment of comments) {
+      state.processedCommentIds.add(comment.id);
+    }
+    if (verbose) {
+      await log(`📋 Bidirectional mode: Initialized with ${comments.length} existing comments`, { verbose: true });
+    }
+    return comments.length;
+  };
+
+  /**
+   * Attach a live Claude stdin stream to the handler.
+   *
+   * Issue #817: Once attached, every new non-system comment detected by the
+   * polling loop is also written to this stream as a NDJSON `user` frame.
+   * Safe to call before or after monitoring starts.
+   *
+   * @param {Object} stream - Writable stream (child.stdin)
+   */
+  const attachClaudeStdin = stream => {
+    state.claudeStdin = stream || null;
+  };
+
+  /**
+   * Detach the Claude stdin stream. After this call, comments are only queued.
+   */
+  const detachClaudeStdin = () => {
+    state.claudeStdin = null;
+  };
+
+  /**
+   * Stream the initial user prompt as a stream-json frame into the attached
+   * Claude stdin. Use this when running Claude with `--input-format stream-json`.
+   *
+   * @param {string} promptText
+   * @param {Object} [options]
+   * @param {string} [options.sessionId]
+   * @returns {Promise<boolean>} Whether the write succeeded
+   */
+  const streamInitialPrompt = async (promptText, options = {}) => {
+    if (!state.claudeStdin) return false;
+    const frame = buildInitialUserFrame(promptText, options);
+    return writeFrameToStdin(state.claudeStdin, frame, log, verbose);
+  };
+
+  /**
+   * Get current handler state (for debugging)
+   *
+   * @returns {Object} Current state
+   */
+  const getState = () => ({
+    isMonitoring: state.isMonitoring,
+    feedbackQueueLength: state.feedbackQueue.length,
+    processedCommentCount: state.processedCommentIds.size,
+    totalCommentsProcessed: state.totalCommentsProcessed,
+    totalFeedbackQueued: state.totalFeedbackQueued,
+    totalFeedbackStreamed: state.totalFeedbackStreamed,
+    isStreamingAttached: !!state.claudeStdin,
+  });
+
+  return {
+    startMonitoring,
+    stopMonitoring,
+    peekFeedback,
+    popFeedback,
+    getAllQueuedFeedback,
+    hasFeedback,
+    getFeedbackCount,
+    clearFeedbackQueue,
+    markCommentAsProcessed,
+    initializeWithExistingComments,
+    initializeFromCurrentComments,
+    attachClaudeStdin,
+    detachClaudeStdin,
+    streamInitialPrompt,
+    getState,
+    // Expose for testing
+    _internal: {
+      checkForNewComments,
+      fetchRecentComments,
+      isSystemComment,
+      formatFeedbackForClaude,
+      buildInitialUserFrame,
+      writeFrameToStdin,
+    },
+  };
+};
+
+/**
+ * Check if bidirectional interactive mode is supported for the given tool
+ *
+ * @param {string} tool - Tool name (claude, opencode, codex)
+ * @returns {boolean} Whether bidirectional interactive mode is supported
+ */
+export const isBidirectionalModeSupported = tool => {
+  // Currently only supported for Claude due to --input-format stream-json support
+  return tool === 'claude';
+};
+
+/**
+ * Apply bidirectional interactive mode composition and validation.
+ *
+ * Semantics (Issue #817):
+ * - --bidirectional-interactive-mode is a convenience flag that automatically enables
+ *   --interactive-mode, --accept-incomming-comments-as-input and
+ *   --exclude-all-own-incomming-comments-from-input.
+ * - Individual flags can still be used on their own (e.g. --interactive-mode with
+ *   --accept-incomming-comments-as-input but without --exclude-all-own-..., which lets
+ *   the same GitHub user "talk to themself").
+ * - All three flags default to disabled and the behavior is experimental.
+ *
+ * @param {Object} argv - Parsed command line arguments (mutated in place)
+ * @param {Function} log - Logging function
+ * @returns {Promise<boolean>} Whether configuration is valid for the chosen tool
+ */
+export const validateBidirectionalModeConfig = async (argv, log) => {
+  // Composition: --bidirectional-interactive-mode implies the three experimental flags.
+  if (argv.bidirectionalInteractiveMode) {
+    if (!argv.interactiveMode) argv.interactiveMode = true;
+    if (!argv.acceptIncommingCommentsAsInput) argv.acceptIncommingCommentsAsInput = true;
+    if (!argv.excludeAllOwnIncommingCommentsFromInput) argv.excludeAllOwnIncommingCommentsFromInput = true;
+  }
+
+  // Nothing more to validate if no incoming-comment acceptance is requested
+  if (!argv.acceptIncommingCommentsAsInput) return true;
+
+  // Tool support: currently only Claude (uses --input-format stream-json)
+  if (!isBidirectionalModeSupported(argv.tool)) {
+    await log(`⚠️ --accept-incomming-comments-as-input is only supported for --tool claude (current: ${argv.tool})`, { level: 'warning' });
+    await log('   Incoming-comment acceptance will be disabled for this session.', { level: 'warning' });
+    argv.acceptIncommingCommentsAsInput = false;
+    argv.excludeAllOwnIncommingCommentsFromInput = false;
+    return false;
+  }
+
+  await log('🔌 Bidirectional Interactive Mode: ENABLED (experimental)', { level: 'info' });
+  await log(`   accept-incomming-comments-as-input: true${argv.excludeAllOwnIncommingCommentsFromInput ? ', exclude-all-own-incomming-comments-from-input: true' : ''}`, { level: 'info' });
+  await log('   PR comments will be monitored and queued as feedback for Claude.', { level: 'info' });
+
+  return true;
+};
+
+/**
+ * Set up the bidirectional handler for an execution. Returns `null` when the
+ * feature is not requested or PR info is missing — callers can treat a null
+ * return as "no-op".
+ *
+ * @param {Object} params
+ * @param {Object} params.argv - Parsed CLI args (expects `acceptIncommingCommentsAsInput`,
+ *   `excludeAllOwnIncommingCommentsFromInput`, `verbose`).
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {string|number} params.prNumber
+ * @param {Function} params.$ - command-stream tagged template
+ * @param {Function} params.log
+ * @returns {Promise<Object|null>} Started handler or null when inactive.
+ */
+export const setupBidirectionalHandler = async ({ argv, owner, repo, prNumber, $, log }) => {
+  if (!argv.acceptIncommingCommentsAsInput) return null;
+  if (!owner || !repo || !prNumber) {
+    await log('⚠️ Bidirectional mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
+    return null;
+  }
+  await log('🔌 Bidirectional mode: Creating handler to accept incoming PR comments as Claude input', { verbose: true });
+  const handler = createBidirectionalHandler({
+    owner,
+    repo,
+    prNumber,
+    $,
+    log,
+    verbose: argv.verbose,
+    pollInterval: 15000,
+    excludeOwnComments: !!argv.excludeAllOwnIncommingCommentsFromInput,
+  });
+  await handler.initializeFromCurrentComments();
+  await handler.startMonitoring();
+  await log('🔌 Bidirectional mode: Started monitoring PR comments for feedback', { verbose: true });
+  return handler;
+};
+
+/**
+ * Attach a live Claude process to the handler so new comments stream into
+ * its stdin as NDJSON frames. Also writes the initial user prompt as the
+ * first frame so the run starts normally. Issue #817.
+ *
+ * Safe to call with a null handler (no-op). Logs diagnostics but never throws.
+ *
+ * @param {Object|null} handler - Handler from setupBidirectionalHandler, or null
+ * @param {Object} execCommand - command-stream ProcessRunner with `streams.stdin`
+ * @param {string} prompt - Initial user prompt text
+ * @param {Function} log
+ * @param {boolean} [verbose=false]
+ * @returns {Promise<boolean>} Whether streaming input is active
+ */
+export const attachStreamingInput = async (handler, execCommand, prompt, log, verbose = false) => {
+  if (!handler || !execCommand) return false;
+  try {
+    const stdinStream = await execCommand.streams.stdin;
+    if (!stdinStream) {
+      if (verbose) await log('⚠️ Bidirectional mode: Could not acquire Claude stdin stream; falling back to queued-only feedback.', { verbose: true });
+      return false;
+    }
+    handler.attachClaudeStdin(stdinStream);
+    const ok = await handler.streamInitialPrompt(prompt);
+    if (verbose) await log(`🔌 Bidirectional mode: Streaming input ${ok ? 'ENABLED' : 'FAILED'} (wrote initial user frame to Claude stdin).`, { verbose: true });
+    return ok;
+  } catch (attachError) {
+    await log(`⚠️ Bidirectional mode: Failed to attach stdin (${attachError.message}); continuing without live streaming.`, { verbose: true });
+    return false;
+  }
+};
+
+/**
+ * Stop the handler, flush its queue, and log a summary. Safe to call with a
+ * null handler (returns an empty array).
+ *
+ * @param {Object|null} handler - Handler returned by setupBidirectionalHandler, or null.
+ * @param {Function} log
+ * @returns {Promise<Array>} Queued feedback messages (possibly empty).
+ */
+export const finalizeBidirectionalHandler = async (handler, log) => {
+  if (!handler) return [];
+  try {
+    handler.detachClaudeStdin?.();
+    await handler.stopMonitoring();
+    const state = handler.getState();
+    const queuedFeedback = handler.getAllQueuedFeedback();
+    if (queuedFeedback.length > 0) {
+      await log(`\n📥 Bidirectional mode: ${queuedFeedback.length} feedback message(s) received during execution`, { level: 'info' });
+      for (const feedback of queuedFeedback) {
+        await log(`   • From @${feedback.user}: ${feedback.body.substring(0, 100)}${feedback.body.length > 100 ? '...' : ''}`, { level: 'info' });
+      }
+      if (state.totalFeedbackStreamed > 0) {
+        await log(`   📤 ${state.totalFeedbackStreamed} of these were streamed live into Claude stdin.`, { level: 'info' });
+      } else {
+        await log('   💡 This feedback will be available for the next continuation of this task.', { level: 'info' });
+      }
+    } else {
+      await log('📊 Bidirectional mode: No new feedback received during execution', { verbose: true });
+    }
+    await log(`📊 Bidirectional mode stats: ${state.totalCommentsProcessed} comments processed, ${state.totalFeedbackQueued} feedback queued, ${state.totalFeedbackStreamed} streamed into Claude stdin`, { verbose: true });
+    return queuedFeedback;
+  } catch (bidirectionalError) {
+    await log(`⚠️ Bidirectional mode cleanup error: ${bidirectionalError.message}`, { verbose: true });
+    return [];
+  }
+};
+
+// Export utilities for testing
+export const utils = {
+  isSystemComment,
+  formatFeedbackForClaude,
+  buildInitialUserFrame,
+  writeFrameToStdin,
+  CONFIG,
+};
+
+// Export all functions
+export default {
+  createBidirectionalHandler,
+  isBidirectionalModeSupported,
+  validateBidirectionalModeConfig,
+  setupBidirectionalHandler,
+  finalizeBidirectionalHandler,
+  utils,
+};

package/src/claude.lib.mjs

@@ -11,6 +11,7 @@ import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET, getMaxOutputTokensForModel } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
+import { setupBidirectionalHandler, finalizeBidirectionalHandler, validateBidirectionalModeConfig, attachStreamingInput } from './bidirectional-interactive.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import Decimal from 'decimal.js-light';
@@ -632,6 +633,10 @@ export const executeClaudeCommand = async params => {
     repo,
     prNumber,
   } = params;
+  // Issue #817: Apply bidirectional-mode composition and tool-support validation before running.
+  // This may enable argv.interactiveMode, argv.acceptIncommingCommentsAsInput, and
+  // argv.excludeAllOwnIncommingCommentsFromInput when --bidirectional-interactive-mode is set.
+  await validateBidirectionalModeConfig(argv, log);
   // Issue #1331: Unified retry configuration for all transient API errors
   // (Overloaded, 503 Network Error, Internal Server Error) - same params, all with session preservation
   let retryCount = 0;
@@ -715,6 +720,9 @@ export const executeClaudeCommand = async params => {
     } else if (argv.interactiveMode) {
       await log('⚠️ Interactive mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
     }
+    // Issue #817: Set up bidirectional handler when --accept-incomming-comments-as-input
+    // (or composite --bidirectional-interactive-mode) is enabled. Returns null when inactive.
+    const bidirectionalHandler = await setupBidirectionalHandler({ argv, owner, repo, prNumber, $, log });
     const progressMonitor = await initProgressMonitoring(argv, { owner, repo, prNumber, $, log }); // works with or without --interactive-mode
     let execCommand;
     const mappedModel = mapModelToId(argv.model);
@@ -722,6 +730,12 @@ export const executeClaudeCommand = async params => {
     const effectiveModel = resolvedPlanModel ? 'opusplan' : mappedModel;
     const resolvedExecutionModel = resolvedPlanModel ? mappedModel : undefined;
     let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel}`;
+    // Declare queuedFeedback for use in catch/finally blocks and return value
+    let queuedFeedback = [];
+    // Issue #817: When --accept-incomming-comments-as-input is set and we are
+    // not resuming a prior session, drive Claude via NDJSON stream-json input
+    // so incoming PR comments can be streamed as additional user turns.
+    const streamingInput = !!(argv.acceptIncommingCommentsAsInput && bidirectionalHandler && !argv.resume);
     if (argv.resume) {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
@@ -730,7 +744,12 @@ export const executeClaudeCommand = async params => {
     const { mcpConfigPath, disallowedToolsList } = await resolveClaudeSessionToolFlags({ argv, log, fallbackBuildMcpConfigWithoutPlaywright: buildMcpConfigWithoutPlaywright });
     if (mcpConfigPath) claudeArgs += ` --strict-mcp-config --mcp-config "${mcpConfigPath}"`;
     if (disallowedToolsList.length) claudeArgs += ` --disallowedTools ${disallowedToolsList.join(' ')}`;
-    claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
+    if (streamingInput) {
+      // Prompt is delivered as the first NDJSON frame on stdin (not as -p).
+      claudeArgs += ` -p --input-format stream-json --append-system-prompt "${escapedSystemPrompt}"`;
+    } else {
+      claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
+    }
     const fullCommand = `(cd "${tempDir}" && ${claudePath} ${claudeArgs} | jq -c .)`;
     await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
     await log(`${fullCommand}`);
@@ -741,7 +760,9 @@ export const executeClaudeCommand = async params => {
     }
     try {
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent });
+      // Issue #817: Streaming mode sets exitAfterStopDelayMs=60000 so the
+      // headless Claude process stays alive between NDJSON turns.
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined });
       if (argv.verbose) claudeEnv.ANTHROPIC_LOG = 'debug';
       const modelMaxOutputTokens = getMaxOutputTokensForModel(effectiveModel);
       if (argv.verbose) {
@@ -758,9 +779,18 @@ export const executeClaudeCommand = async params => {
       if (argv.resume) {
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
         execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} ${disallowedToolsArgs} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
+      } else if (streamingInput) {
+        // Issue #817: Drive Claude via --input-format stream-json on a pipe
+        // stdin. Initial prompt + later PR comments are written as NDJSON
+        // frames by attachStreamingInput (see bidirectional-interactive.lib.mjs).
+        const streamingInputArgs = ['-p', '--input-format', 'stream-json'];
+        execCommand = $({ cwd: tempDir, stdin: 'pipe', mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} ${disallowedToolsArgs} ${streamingInputArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       } else {
         execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} ${disallowedToolsArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       }
+      if (streamingInput) {
+        await attachStreamingInput(bidirectionalHandler, execCommand, prompt, log, !!argv.verbose);
+      }
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));
       await log(formatAligned('🌿', 'Branch:', branchName, 2));
@@ -1116,6 +1146,8 @@ export const executeClaudeCommand = async params => {
         }
       }
 
+      // Issue #817: Stop bidirectional mode monitoring and collect queued feedback
+      queuedFeedback = await finalizeBidirectionalHandler(bidirectionalHandler, log);
       // Issues #1331, #1353, #1472/#1475: Unified transient error retry (exponential backoff, session preservation)
       const isTransientError = isStartupTimeout || isActivityTimeout || isOverloadError || isInternalServerError || is503Error || isRequestTimeout || (lastMessage.includes('API Error: 500') && (lastMessage.includes('Overloaded') || lastMessage.includes('Internal server error'))) || (lastMessage.includes('API Error: 529') && (lastMessage.includes('overloaded_error') || lastMessage.includes('Overloaded'))) || (lastMessage.includes('api_error') && lastMessage.includes('Overloaded')) || (lastMessage.includes('overloaded_error') && lastMessage.includes('Overloaded')) || lastMessage.includes('API Error: 503') || (lastMessage.includes('503') && (lastMessage.includes('upstream connect error') || lastMessage.includes('remote connection failure'))) || lastMessage === 'Request timed out' || lastMessage.includes('Request timed out');
       if ((commandFailed || isTransientError) && isTransientError) {
@@ -1141,6 +1173,7 @@ export const executeClaudeCommand = async params => {
             is503Error,
             anthropicTotalCostUSD,
             resultSummary,
+            queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
         if (retryCount < maxRetries) {
@@ -1183,6 +1216,7 @@ export const executeClaudeCommand = async params => {
             is503Error, // preserve for callers that check this
             anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
             resultSummary, // Issue #1263: Include result summary
+            queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
       }
@@ -1242,6 +1276,7 @@ export const executeClaudeCommand = async params => {
           errorDuringExecution,
           anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           resultSummary, // Issue #1263: Include result summary
+          queuedFeedback, // Issue #817: Bidirectional mode feedback
         };
       }
       // Issue #1088/#1351: Log execution result status
@@ -1330,6 +1365,7 @@ export const executeClaudeCommand = async params => {
         resultModelUsage, // Issue #1454
         streamTokenUsage: streamTokenUsage.eventCount > 0 ? streamTokenUsage : null, // Issue #1491
         subAgentCalls: subAgentCalls.length > 0 ? subAgentCalls : null, // Issue #1590
+        queuedFeedback, // Issue #817: Bidirectional mode feedback
       };
     } catch (error) {
       reportError(error, {
@@ -1371,6 +1407,7 @@ export const executeClaudeCommand = async params => {
         toolUseCount,
         anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
         resultSummary, // Issue #1263: Include result summary
+        queuedFeedback, // Issue #817: Bidirectional mode feedback
       };
     }
   }; // End of executeWithRetry function

package/src/config.lib.mjs

@@ -463,6 +463,14 @@ export const getClaudeEnv = (options = {}) => {
   if (options.showThinkingContent) {
     env.CLAUDE_CODE_SHOW_THINKING = '1';
   }
+  // Issue #817: When bidirectional streaming input is enabled, keep the headless
+  // Claude process alive between turns so newly arriving PR comments can be
+  // streamed into stdin as additional user messages. Without this env var the
+  // process would exit as soon as the first --input-format stream-json frame
+  // is processed. Default is 1 minute (60000ms), matching the reference gist.
+  if (options.exitAfterStopDelayMs) {
+    env.CLAUDE_CODE_EXIT_AFTER_STOP_DELAY_MS = String(options.exitAfterStopDelayMs);
+  }
   // Set ANTHROPIC_DEFAULT_OPUS_MODEL when planModel is specified (Issue #1223)
   // This tells Claude Code which model to use during plan mode in opusplan
   if (options.planModel) {

package/src/github-merge-ci.lib.mjs

@@ -185,8 +185,10 @@ export async function checkBranchCIHealth(owner, repo, branch = 'main', options,
 
     // Issue #1425: Query CI runs specifically for the HEAD SHA (no status filter).
     // This ensures we see in-progress runs for the latest commit, not just completed ones.
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${headSha}&per_page=20" --jq '[.workflow_runs[] | {id: .id, name: .name, status: .status, conclusion: .conclusion, html_url: .html_url, head_sha: .head_sha, created_at: .created_at}]'`);
-    const runs = JSON.parse(stdout.trim() || '[]');
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${headSha}&per_page=100" --paginate --slurp`);
+    const runs = JSON.parse(stdout.trim() || '[]')
+      .flatMap(page => page.workflow_runs || [])
+      .map(run => ({ id: run.id, name: run.name, status: run.status, conclusion: run.conclusion, html_url: run.html_url, head_sha: run.head_sha, created_at: run.created_at }));
 
     if (verbose) {
       console.log(`[VERBOSE] /merge: Found ${runs.length} CI run(s) for HEAD commit ${headSha.substring(0, 7)} on ${owner}/${repo} branch ${branch}`);

package/src/github-merge-repo-actions.lib.mjs

@@ -22,10 +22,11 @@ const exec = promisify(execCallback);
  */
 export async function getAllActiveRepoRuns(owner, repo, verbose = false) {
   try {
-    const activeFilter = '.workflow_runs[] | select(.status=="in_progress" or .status=="queued" or .status=="waiting" or .status=="requested" or .status=="pending")';
-    const fields = '{id: .id, name: .name, status: .status, head_branch: .head_branch, head_sha: (.head_sha[:7])}';
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?per_page=100" --jq '[${activeFilter}] | map(${fields})'`);
-    const runs = JSON.parse(stdout.trim() || '[]');
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?per_page=100" --paginate --slurp`);
+    const runs = JSON.parse(stdout.trim() || '[]')
+      .flatMap(page => page.workflow_runs || [])
+      .filter(run => ['in_progress', 'queued', 'waiting', 'requested', 'pending'].includes(run.status))
+      .map(run => ({ id: run.id, name: run.name, status: run.status, head_branch: run.head_branch, head_sha: run.head_sha?.slice(0, 7) }));
     if (verbose && runs.length > 0) {
       console.log(`[VERBOSE] repo-actions: ${runs.length} active run(s) in ${owner}/${repo}`);
       for (const r of runs) console.log(`[VERBOSE] repo-actions:   ${r.name} (${r.status}) on ${r.head_branch}`);

package/src/github-merge.lib.mjs

@@ -313,9 +313,8 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
     const prData = JSON.parse(prJson.trim());
     const sha = prData.headRefOid;
 
-    // Get check runs for this SHA
-    const { stdout: checksJson } = await exec(`gh api repos/${owner}/${repo}/commits/${sha}/check-runs --paginate --jq '.check_runs'`);
-    const checkRuns = JSON.parse(checksJson.trim() || '[]');
+    const { stdout: checksJson } = await exec(`gh api repos/${owner}/${repo}/commits/${sha}/check-runs --paginate --slurp`);
+    const checkRuns = JSON.parse(checksJson.trim() || '[]').flatMap(page => page.check_runs || []);
 
     // Get commit statuses (some CI systems use status API instead of checks API)
     const { stdout: statusJson } = await exec(`gh api repos/${owner}/${repo}/commits/${sha}/status --jq '.statuses'`);
@@ -685,9 +684,11 @@ export function parseRepositoryUrl(url) {
 export async function getActiveBranchRuns(owner, repo, branch = 'main', verbose = false) {
   try {
     // Query for in_progress and queued runs on the specified branch
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?branch=${branch}&per_page=10" --jq '[.workflow_runs[] | select(.status=="in_progress" or .status=="queued")] | map({id: .id, name: .name, status: .status, created_at: .created_at, html_url: .html_url})'`);
-
-    const runs = JSON.parse(stdout.trim() || '[]');
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?branch=${branch}&per_page=100" --paginate --slurp`);
+    const runs = JSON.parse(stdout.trim() || '[]')
+      .flatMap(page => page.workflow_runs || [])
+      .filter(run => run.status === 'in_progress' || run.status === 'queued')
+      .map(run => ({ id: run.id, name: run.name, status: run.status, created_at: run.created_at, html_url: run.html_url }));
 
     if (verbose) {
       console.log(`[VERBOSE] /merge: Found ${runs.length} active runs on ${owner}/${repo} branch ${branch}`);
@@ -839,7 +840,7 @@ export async function getDefaultBranch(owner, repo, verbose = false) {
  */
 export async function getCheckRunAnnotations(owner, repo, checkRunId, verbose = false) {
   try {
-    const { stdout } = await exec(`gh api repos/${owner}/${repo}/check-runs/${checkRunId}/annotations 2>/dev/null || echo "[]"`);
+    const { stdout } = await exec(`gh api repos/${owner}/${repo}/check-runs/${checkRunId}/annotations --paginate 2>/dev/null || echo "[]"`);
     const annotations = JSON.parse(stdout.trim() || '[]');
 
     if (verbose) {
@@ -895,12 +896,6 @@ export const BILLING_LIMIT_ERROR_PATTERN = 'The job was not started because rece
  * Check if CI failure is due to billing/spending limits
  * Issue #1314: Detects when GitHub Actions jobs fail due to billing issues rather than code problems
  *
- * Detection criteria:
- * 1. Job has conclusion='failure'
- * 2. Job has empty steps array (no steps were executed)
- * 3. Job has runner_id=0 or null (no runner was assigned)
- * 4. Annotation contains the billing limit error message
- *
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {number} prNumber - Pull request number
@@ -909,14 +904,14 @@ export const BILLING_LIMIT_ERROR_PATTERN = 'The job was not started because rece
  */
 export async function checkForBillingLimitError(owner, repo, prNumber, verbose = false) {
   try {
-    // Get the PR's head SHA
     const { stdout: prJson } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json headRefOid`);
     const prData = JSON.parse(prJson.trim());
     const sha = prData.headRefOid;
 
-    // Get workflow runs for this SHA
-    const { stdout: runsJson } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=10" --jq '.workflow_runs[].id'`);
-    const runIds = runsJson.trim().split('\n').filter(Boolean);
+    const { stdout: runsJson } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=100" --paginate --slurp`);
+    const runIds = JSON.parse(runsJson.trim() || '[]')
+      .flatMap(page => page.workflow_runs || [])
+      .map(run => run.id);
 
     if (verbose) {
       console.log(`[VERBOSE] /merge: Found ${runIds.length} workflow runs for PR #${prNumber} at SHA ${sha.substring(0, 7)}`);
@@ -925,11 +920,10 @@ export async function checkForBillingLimitError(owner, repo, prNumber, verbose =
     const affectedJobs = [];
     let totalJobs = 0;
 
-    // Check each workflow run's jobs
     for (const runId of runIds) {
       try {
-        const { stdout: jobsJson } = await exec(`gh api repos/${owner}/${repo}/actions/runs/${runId}/jobs --jq '.jobs'`);
-        const jobs = JSON.parse(jobsJson.trim() || '[]');
+        const { stdout: jobsJson } = await exec(`gh api repos/${owner}/${repo}/actions/runs/${runId}/jobs --paginate --slurp`);
+        const jobs = JSON.parse(jobsJson.trim() || '[]').flatMap(page => page.jobs || []);
 
         for (const job of jobs) {
           totalJobs++;
@@ -1068,9 +1062,8 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
     const prData = JSON.parse(prJson.trim());
     const sha = prData.headRefOid;
 
-    // Get check runs for this SHA
-    const { stdout: checksJson } = await exec(`gh api repos/${owner}/${repo}/commits/${sha}/check-runs --paginate --jq '.check_runs'`);
-    const checkRuns = JSON.parse(checksJson.trim() || '[]');
+    const { stdout: checksJson } = await exec(`gh api repos/${owner}/${repo}/commits/${sha}/check-runs --paginate --slurp`);
+    const checkRuns = JSON.parse(checksJson.trim() || '[]').flatMap(page => page.check_runs || []);
 
     // Get commit statuses
     const { stdout: statusJson } = await exec(`gh api repos/${owner}/${repo}/commits/${sha}/status --jq '.statuses'`);
@@ -1214,8 +1207,10 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
  */
 export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
   try {
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=20" --jq '[.workflow_runs[] | {id: .id, status: .status, conclusion: .conclusion, name: .name, html_url: .html_url}]'`);
-    const runs = JSON.parse(stdout.trim() || '[]');
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=100" --paginate --slurp`);
+    const runs = JSON.parse(stdout.trim() || '[]')
+      .flatMap(page => page.workflow_runs || [])
+      .map(run => ({ id: run.id, status: run.status, conclusion: run.conclusion, name: run.name, html_url: run.html_url }));
 
     if (verbose) {
       console.log(`[VERBOSE] /merge: Found ${runs.length} workflow runs for SHA ${sha.substring(0, 7)}`);
@@ -1251,13 +1246,13 @@ export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
  */
 export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
   try {
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/workflows" --jq '[.workflows[] | select(.state == "active")] | map({id: .id, name: .name, state: .state, path: .path})'`);
-    const allWorkflows = JSON.parse(stdout.trim() || '[]');
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/workflows" --paginate --slurp`);
+    const allWorkflows = JSON.parse(stdout.trim() || '[]')
+      .flatMap(page => page.workflows || [])
+      .filter(workflow => workflow.state === 'active')
+      .map(workflow => ({ id: workflow.id, name: workflow.name, state: workflow.state, path: workflow.path }));
 
-    // Issue #1399: Filter out GitHub Pages deployment workflows.
-    // These have path "dynamic/pages/pages-build-deployment" and only run on the
-    // default branch after merge — they never produce check-runs on PR branches.
-    // Including them causes an infinite loop when waiting for PR CI checks.
+    // GitHub Pages workflows only run after merge and never produce PR check-runs.
     const workflows = allWorkflows.filter(wf => !wf.path.startsWith('dynamic/pages/'));
 
     if (verbose) {
@@ -1351,8 +1346,8 @@ export async function checkPreviousPRCommitsHadCI(owner, repo, prNumber, headSha
 
     for (const sha of commitsToCheck) {
       try {
-        const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=1" --jq '.total_count'`);
-        const count = parseInt(stdout.trim(), 10);
+        const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=100" --paginate --slurp`);
+        const count = JSON.parse(stdout.trim() || '[]').reduce((sum, page) => sum + (page.workflow_runs?.length || 0), 0);
         if (count > 0) {
           commitsWithCI++;
         }
@@ -1390,7 +1385,7 @@ export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false,
     // Issue #1503: Support querying workflow files from a specific branch (ref)
     const refParam = ref ? `?ref=${encodeURIComponent(ref)}` : '';
     // List workflow files in .github/workflows/ (uses ref if provided, otherwise default branch)
-    const { stdout: listJson } = await exec(`gh api "repos/${owner}/${repo}/contents/.github/workflows${refParam}" --jq '[.[] | select(.name | test("\\\\.(yml|yaml)$")) | {name: .name, download_url: .download_url, path: .path}]' 2>/dev/null`);
+    const { stdout: listJson } = await exec(`gh api "repos/${owner}/${repo}/contents/.github/workflows${refParam}" --paginate --jq '[.[] | select(.name | test("\\\\.(yml|yaml)$")) | {name: .name, download_url: .download_url, path: .path}]' 2>/dev/null`);
     const files = JSON.parse(listJson.trim() || '[]');
 
     if (files.length === 0) {

package/src/log-upload.lib.mjs

@@ -149,7 +149,7 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
             if (verbose) {
               await log(`  🔍 Fetching repository contents for raw URL resolution (repoPath=${repoPath})`, { verbose: true });
             }
-            const contentsResult = await $silent`gh api repos/${repoPath}/contents --jq '.[].name'`;
+            const contentsResult = await $silent`gh api repos/${repoPath}/contents --paginate --jq '.[].name'`;
             if (verbose) {
               await log(`  📥 Repository contents fetch completed (code=${contentsResult.code ?? 'unknown'})`, { verbose: true });
             }

package/src/solve.accept-invite.lib.mjs

@@ -43,7 +43,7 @@ export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
 
   // Check for pending repository invitation
   try {
-    const { stdout: repoInvJson } = await ghRetry(() => exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"'), { label: 'fetch repo invitations' });
+    const { stdout: repoInvJson } = await ghRetry(() => exec('gh api /user/repository_invitations --paginate 2>/dev/null || echo "[]"'), { label: 'fetch repo invitations' });
     const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
     verbose && (await log(`   Found ${repoInvitations.length} total pending repo invitation(s)`, { verbose: true }));
 
@@ -66,7 +66,7 @@ export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
 
   // Check for pending organization membership
   try {
-    const { stdout: orgMemJson } = await ghRetry(() => exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"'), { label: 'fetch org memberships' });
+    const { stdout: orgMemJson } = await ghRetry(() => exec('gh api /user/memberships/orgs --paginate 2>/dev/null || echo "[]"'), { label: 'fetch org memberships' });
     const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
     const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
     verbose && (await log(`   Found ${pendingOrgs.length} total pending org invitation(s)`, { verbose: true }));

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

@@ -63,12 +63,14 @@ const { SESSION_ENDING_MARKERS } = toolComments;
  * @param {number} prNumber - Pull request number
  * @param {string} commentSignature - Unique signature to search for in comment body (e.g., "✅ Ready to merge")
  * @param {boolean} verbose - Enable verbose logging
+ * @param {Function} commandRunner - Tagged-template command runner, injectable for tests
  * @returns {Promise<boolean>} - True if a matching comment already exists
  */
-export const checkForExistingComment = async (owner, repo, prNumber, commentSignature, verbose = false) => {
+export const checkForExistingComment = async (owner, repo, prNumber, commentSignature, verbose = false, commandRunner = $) => {
   try {
-    // Fetch all PR comments as JSON to get individual comment bodies in order
-    const result = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --jq '[.[].body]' 2>/dev/null`;
+    // Fetch every PR comment page so long threads don't scope deduplication to
+    // a stale first-page session-ending marker.
+    const result = await commandRunner`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate --jq '[.[].body]' 2>/dev/null`;
     if (result.code === 0 && result.stdout) {
       const rawOutput = result.stdout.toString().trim();
       if (!rawOutput) return false;

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

@@ -604,7 +604,7 @@ Proceed.
           }
           compareResult = await $({
             silent: true,
-          })`gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${headRef} --jq '.ahead_by' 2>&1`;
+          })`gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${headRef} --paginate --jq '.ahead_by' 2>&1`;
 
           if (compareResult.code === 0) {
             const aheadBy = parseInt(compareResult.stdout.toString().trim(), 10);
@@ -798,9 +798,9 @@ Proceed.
             // Use the correct head reference for the compare API check
             if (argv.fork && forkedRepo) {
               const forkUser = forkedRepo.split('/')[0];
-              await log(`        gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${forkUser}:${branchName}`);
+              await log(`        gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${forkUser}:${branchName} --paginate`);
             } else {
-              await log(`        gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${branchName}`);
+              await log(`        gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${branchName} --paginate`);
             }
             await log('');
 

package/src/solve.config.lib.mjs

@@ -334,6 +334,22 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: '[EXPERIMENTAL] Post tool output as PR comments in real-time. Supported for --tool claude and --tool codex.',
     default: false,
   },
+  // Issue #817: Bidirectional interactive options
+  'accept-incomming-comments-as-input': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Accept new PR/issue comments as input for Claude during execution (excludes outgoing comments generated by solve itself). Does not require --interactive-mode; disabled by default. Only supported for --tool claude.',
+    default: false,
+  },
+  'exclude-all-own-incomming-comments-from-input': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] When combined with --accept-incomming-comments-as-input, also exclude comments written by the same GitHub user that solve runs as (prevents self-talk). Disabled by default.',
+    default: false,
+  },
+  'bidirectional-interactive-mode': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Convenience flag that enables --interactive-mode, --accept-incomming-comments-as-input and --exclude-all-own-incomming-comments-from-input together. Only supported for --tool claude.',
+    default: false,
+  },
   'prompt-explore-sub-agent': {
     type: 'boolean',
     description: 'Encourage AI to use Explore-style sub-agent workflow for codebase exploration. Supported for --tool claude and --tool codex.',

package/src/solve.feedback.lib.mjs

@@ -329,10 +329,12 @@ export const detectAndCountFeedback = async params => {
 
           // 6. Check for failed PR checks
           try {
-            const checksResult = await $`gh api repos/${owner}/${repo}/commits/$(gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.head.sha')/check-runs --paginate`;
-            if (checksResult.code === 0) {
-              const checksData = JSON.parse(checksResult.stdout.toString());
-              const failedChecks = checksData.check_runs?.filter(check => check.conclusion === 'failure' && new Date(check.completed_at) > lastCommitTime) || [];
+            const prHeadResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.head.sha'`;
+            if (prHeadResult.code === 0) {
+              const prHeadSha = prHeadResult.stdout.toString().trim();
+              const checksResult = await $`gh api repos/${owner}/${repo}/commits/${prHeadSha}/check-runs --paginate --slurp`;
+              const checkRuns = checksResult.code === 0 ? JSON.parse(checksResult.stdout.toString() || '[]').flatMap(page => page.check_runs || []) : [];
+              const failedChecks = checkRuns.filter(check => check.conclusion === 'failure' && new Date(check.completed_at) > lastCommitTime);
 
               if (failedChecks.length > 0) {
                 feedbackLines.push(`Failed pull request checks: ${failedChecks.length}`);

package/src/solve.progress-monitoring.lib.mjs

@@ -242,7 +242,7 @@ export const createProgressMonitor = ({ owner, repo, prNumber, $, log, verbose =
           state.commentId = posted.commentId;
         } else {
           // Fallback: find the comment we just created by looking for our marker
-          const commentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --jq ${`[.[] | select(.body | contains("${CONFIG.PROGRESS_SECTION_START}")) | .id] | last`}`;
+          const commentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate --jq ${`[.[] | select(.body | contains("${CONFIG.PROGRESS_SECTION_START}")) | .id] | last`}`;
           const commentId = commentsResult.stdout?.toString?.().trim();
           if (commentId && commentId !== 'null') {
             state.commentId = commentId;

package/src/solve.repository.lib.mjs

@@ -525,7 +525,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
         await log(`${formatAligned('🔍', 'Safety check:', 'Comparing commits against upstream...')}`);
         let safeToDelete = false;
         try {
-          const cmp = await $`gh api repos/${owner}/${repo}/compare/${owner}:HEAD...${existingForkName.split('/')[0]}:HEAD --jq '.ahead_by' 2>&1`;
+          const cmp = await $`gh api repos/${owner}/${repo}/compare/${owner}:HEAD...${existingForkName.split('/')[0]}:HEAD --paginate --jq '.ahead_by' 2>&1`;
           if (cmp.code === 0 && parseInt(cmp.stdout.toString().trim(), 10) === 0) {
             await log(`${formatAligned('✅', 'Safe to delete:', 'No additional commits in non-fork repository')}`);
             safeToDelete = true;

package/src/telegram-accept-invitations.lib.mjs

@@ -174,13 +174,13 @@ export function registerAcceptInvitesCommand(bot, options) {
 
     try {
       // Fetch repository invitations
-      const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
+      const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations --paginate 2>/dev/null || echo "[]"');
       const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
       state.totalRepos = repoInvitations.length;
       VERBOSE && console.log(`[VERBOSE] Found ${repoInvitations.length} pending repo invitations`);
 
       // Fetch organization invitations
-      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs --paginate 2>/dev/null || echo "[]"');
       const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
       const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
       state.totalOrgs = pendingOrgs.length;