@link-assistant/hive-mind 1.58.0 → 1.59.1

package/src/bidirectional-interactive.lib.mjs

@@ -56,9 +56,31 @@ const isSystemComment = body => {
  * Format a user feedback message for Claude CLI's stream-json input
  *
  * @param {string} feedbackText - The user's feedback text
+ * @param {Object} [options]
+ * @param {string} [options.kind='comment'] - Source kind: 'comment', 'ci', 'uncommitted', 'metadata'
  * @returns {string} JSON string ready to write to Claude's stdin
  */
-const formatFeedbackForClaude = feedbackText => {
+const formatFeedbackForClaude = (feedbackText, options = {}) => {
+  const kind = options.kind || 'comment';
+  const headers = {
+    comment: {
+      open: '[USER FEEDBACK FROM PR COMMENT]',
+      close: '[END OF USER FEEDBACK - Please address this feedback in your current work]',
+    },
+    ci: {
+      open: '[CI/CD STATUS UPDATE — auto-input-until-mergeable]',
+      close: '[END OF CI STATUS — Please address the failing checks before continuing]',
+    },
+    uncommitted: {
+      open: '[UNCOMMITTED CHANGES DETECTED — auto-input-until-mergeable]',
+      close: '[END OF UNCOMMITTED CHANGES — Please commit them if part of the solution, or revert them otherwise]',
+    },
+    metadata: {
+      open: '[ISSUE/PR METADATA UPDATE — auto-input-until-mergeable]',
+      close: '[END OF METADATA UPDATE — Please incorporate this into your current work]',
+    },
+  };
+  const { open, close } = headers[kind] || headers.comment;
   const message = {
     type: 'user',
     message: {
@@ -66,7 +88,7 @@ const formatFeedbackForClaude = feedbackText => {
       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]`,
+          text: `${open}\n\n${feedbackText}\n\n${close}`,
         },
       ],
     },
@@ -140,15 +162,20 @@ const writeFrameToStdin = async (stream, jsonFrame, logFn, verbose = false) => {
  * @param {string} options.owner - Repository owner
  * @param {string} options.repo - Repository name
  * @param {number} options.prNumber - Pull request number
+ * @param {number} [options.issueNumber] - Issue number (for issue body/title polling — Issue #1708)
+ * @param {string} [options.tempDir] - Local clone directory (for uncommitted-changes polling — Issue #1708)
  * @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")
+ * @param {string} [options.deliveryMode='stream'] - 'stream' (immediate forward) or 'queue' (hold until AI idle). Issue #1708.
+ * @param {boolean} [options.streamStatusToInput=false] - Also stream CI/uncommitted/PR-status changes as NDJSON frames. Issue #1708.
+ * @param {number} [options.statusPollInterval=60000] - Status-poller interval (ms) when streamStatusToInput is on.
  * @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;
+  const { owner, repo, prNumber, issueNumber, tempDir, $, log, verbose = false, pollInterval = CONFIG.DEFAULT_POLL_INTERVAL, excludeOwnComments = false, deliveryMode = 'stream', streamStatusToInput = false, statusPollInterval = 60000 } = options;
   // Resolved lazily on first check, cached for the lifetime of the handler
   let ownUserLogin = null;
   let ownUserResolved = false;
@@ -182,6 +209,23 @@ export const createBidirectionalHandler = options => {
     // only accumulated in feedbackQueue.
     claudeStdin: null,
     totalFeedbackStreamed: 0,
+    // Issue #1708: Queue-comments-to-input support — buffer NDJSON frames
+    // until the AI signals it is idle (result event seen) and only then
+    // flush them to stdin. In stream mode pendingFrames is bypassed; the
+    // frame is written immediately as before.
+    isAiBusy: false,
+    pendingFrames: [],
+    totalFramesQueued: 0,
+    totalFramesFlushed: 0,
+    // Issue #1708: Status-poller state. When streamStatusToInput is true,
+    // a separate poller emits NDJSON frames for CI/uncommitted/PR-metadata
+    // changes detected during the session. Signatures dedupe so the same
+    // failing check doesn't generate a frame on every poll.
+    statusPollIntervalId: null,
+    statusSignatures: new Set(),
+    lastIssueSnapshot: null,
+    lastPrSnapshot: null,
+    totalStatusFramesSent: 0,
   };
 
   /**
@@ -210,6 +254,96 @@ export const createBidirectionalHandler = options => {
     }
   };
 
+  /**
+   * Issue #1708: Delivery-mode-aware frame dispatcher.
+   *
+   * - In stream mode (default for --accept-incomming-comments-as-input),
+   *   the frame is written to Claude stdin immediately.
+   * - In queue mode (default for --auto-input-until-mergeable), the frame
+   *   is buffered in state.pendingFrames while the AI is busy; on idle
+   *   (markAiIdle) the buffer is flushed to stdin in FIFO order.
+   *
+   * Always returns true if the frame was either written or buffered,
+   * false if the stream is missing/closed.
+   *
+   * @param {string} jsonFrame
+   * @param {Object} [meta]
+   * @param {string} [meta.kind]
+   * @param {string} [meta.label]
+   * @returns {Promise<boolean>}
+   * @private
+   */
+  const dispatchFrame = async (jsonFrame, meta = {}) => {
+    if (!state.claudeStdin) return false;
+    const useQueue = deliveryMode === 'queue';
+    if (useQueue && state.isAiBusy) {
+      if (state.pendingFrames.length < CONFIG.MAX_QUEUE_SIZE) {
+        state.pendingFrames.push({ jsonFrame, meta });
+        state.totalFramesQueued++;
+        if (verbose) {
+          await log(`⏸️ Bidirectional mode: Queued frame (${meta.kind || 'frame'}: ${meta.label || ''}) — AI is busy, will flush on idle`, { verbose: true });
+        }
+        return true;
+      }
+      if (verbose) {
+        await log(`⚠️ Bidirectional mode: Pending-frames buffer full, dropping frame (${meta.kind || 'frame'})`, { verbose: true });
+      }
+      return false;
+    }
+    const ok = await writeFrameToStdin(state.claudeStdin, jsonFrame, log, verbose);
+    if (ok) {
+      state.totalFeedbackStreamed++;
+      if (verbose) {
+        await log(`📤 Bidirectional mode: Streamed frame (${meta.kind || 'frame'}: ${meta.label || ''}) into Claude stdin`, { verbose: true });
+      }
+    }
+    return ok;
+  };
+
+  /**
+   * Issue #1708: Mark the AI as actively processing. While busy, queue mode
+   * holds new frames in state.pendingFrames instead of writing to stdin.
+   * Safe to call repeatedly — idempotent.
+   */
+  const markAiBusy = () => {
+    state.isAiBusy = true;
+  };
+
+  /**
+   * Issue #1708: Mark the AI as idle (waiting for next user input). Triggers
+   * a flush of any frames queued while busy, in FIFO order. Safe to call
+   * repeatedly — flushes only if pendingFrames is non-empty.
+   *
+   * @returns {Promise<number>} Number of frames flushed.
+   */
+  const markAiIdle = async () => {
+    state.isAiBusy = false;
+    if (state.pendingFrames.length === 0) return 0;
+    if (!state.claudeStdin) {
+      if (verbose) {
+        await log(`⚠️ Bidirectional mode: AI idle but no stdin attached — ${state.pendingFrames.length} frame(s) remain queued`, { verbose: true });
+      }
+      return 0;
+    }
+    let flushed = 0;
+    while (state.pendingFrames.length > 0) {
+      const { jsonFrame, meta } = state.pendingFrames.shift();
+      const ok = await writeFrameToStdin(state.claudeStdin, jsonFrame, log, verbose);
+      if (!ok) {
+        // Stream closed mid-flush — push the frame back so finalize can surface it.
+        state.pendingFrames.unshift({ jsonFrame, meta });
+        break;
+      }
+      flushed++;
+      state.totalFramesFlushed++;
+      state.totalFeedbackStreamed++;
+      if (verbose) {
+        await log(`📤 Bidirectional mode: Flushed pending frame (${meta?.kind || 'frame'}: ${meta?.label || ''}) into Claude stdin`, { verbose: true });
+      }
+    }
+    return flushed;
+  };
+
   /**
    * Check for new user comments and queue them as feedback
    * @private
@@ -253,7 +387,7 @@ export const createBidirectionalHandler = options => {
 
         // This is a new user comment - queue it as feedback
         if (state.feedbackQueue.length < CONFIG.MAX_QUEUE_SIZE) {
-          const formattedMessage = formatFeedbackForClaude(comment.body);
+          const formattedMessage = formatFeedbackForClaude(comment.body, { kind: 'comment' });
           state.feedbackQueue.push({
             id: comment.id,
             body: comment.body,
@@ -267,19 +401,12 @@ export const createBidirectionalHandler = options => {
             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 });
-              }
-            }
-          }
+          // Issue #817 / #1708: Dispatch through the delivery-mode router so
+          // queue-comments-to-input can hold the frame until the AI is idle.
+          await dispatchFrame(formattedMessage, {
+            kind: 'comment',
+            label: `comment #${comment.id} from @${comment.user}`,
+          });
         } else {
           if (verbose) {
             await log(`⚠️ Bidirectional mode: Feedback queue full, skipping comment #${comment.id}`, { verbose: true });
@@ -296,6 +423,154 @@ export const createBidirectionalHandler = options => {
     }
   };
 
+  /**
+   * Issue #1708: Fetch a snapshot of an issue's or PR's title+body for
+   * change detection. Returns null when fetching fails — callers treat
+   * null as "skip this round" rather than as an empty snapshot.
+   *
+   * @param {'issue'|'pr'} kind
+   * @param {number} number
+   * @returns {Promise<{title:string, body:string}|null>}
+   * @private
+   */
+  const fetchMetadataSnapshot = async (kind, number) => {
+    if (!number || !owner || !repo) return null;
+    try {
+      const endpoint = kind === 'pr' ? `repos/${owner}/${repo}/pulls/${number}` : `repos/${owner}/${repo}/issues/${number}`;
+      const result = await $`gh api ${endpoint} --jq '{title, body}'`;
+      if (!result || result.code !== 0) return null;
+      const parsed = JSON.parse(result.stdout.toString() || '{}');
+      return { title: parsed.title || '', body: parsed.body || '' };
+    } catch (error) {
+      if (verbose) {
+        await log(`⚠️ Bidirectional mode: Metadata fetch failed for ${kind} #${number}: ${error.message}`, { verbose: true });
+      }
+      return null;
+    }
+  };
+
+  /**
+   * Issue #1708: Diff two metadata snapshots and produce a human-readable
+   * summary. Returns null when nothing changed.
+   *
+   * @param {{title:string, body:string}|null} prev
+   * @param {{title:string, body:string}|null} next
+   * @returns {string|null}
+   * @private
+   */
+  const diffMetadataSnapshot = (prev, next) => {
+    if (!prev || !next) return null;
+    const lines = [];
+    if (prev.title !== next.title) {
+      lines.push(`Title changed:\n  before: ${prev.title}\n  after:  ${next.title}`);
+    }
+    if (prev.body !== next.body) {
+      lines.push(`Body changed (length ${prev.body.length} → ${next.body.length}). New body:\n${next.body}`);
+    }
+    return lines.length > 0 ? lines.join('\n\n') : null;
+  };
+
+  /**
+   * Issue #1708: Status poller. Runs alongside the comment poller while
+   * --auto-input-until-mergeable is on. On every tick, it checks:
+   *   - PR title/body changes (vs the previous snapshot)
+   *   - Issue title/body changes (vs the previous snapshot)
+   *   - Uncommitted changes (git status --porcelain in tempDir)
+   *   - CI/CD blockers (via getMergeBlockers)
+   *
+   * For each change, a one-shot NDJSON frame is dispatched through the
+   * delivery-mode router. Each change is keyed by a stable signature so
+   * the same failing check doesn't re-emit on every poll.
+   *
+   * Failures in any sub-check are swallowed and logged — the poller must
+   * never break the live Claude session.
+   *
+   * @private
+   */
+  const checkForStatusChanges = async () => {
+    if (!state.isMonitoring) return;
+    if (!state.claudeStdin) return;
+    // PR metadata
+    if (prNumber) {
+      const next = await fetchMetadataSnapshot('pr', prNumber);
+      if (next) {
+        if (state.lastPrSnapshot === null) {
+          state.lastPrSnapshot = next;
+        } else {
+          const summary = diffMetadataSnapshot(state.lastPrSnapshot, next);
+          if (summary) {
+            const frame = formatFeedbackForClaude(`Pull request #${prNumber} metadata changed during this session:\n\n${summary}`, { kind: 'metadata' });
+            await dispatchFrame(frame, { kind: 'metadata', label: `PR #${prNumber} title/body` });
+            state.totalStatusFramesSent++;
+            state.lastPrSnapshot = next;
+          }
+        }
+      }
+    }
+    // Issue metadata (only when issueNumber differs from prNumber to avoid double-fetch)
+    if (issueNumber && issueNumber !== prNumber) {
+      const next = await fetchMetadataSnapshot('issue', issueNumber);
+      if (next) {
+        if (state.lastIssueSnapshot === null) {
+          state.lastIssueSnapshot = next;
+        } else {
+          const summary = diffMetadataSnapshot(state.lastIssueSnapshot, next);
+          if (summary) {
+            const frame = formatFeedbackForClaude(`Issue #${issueNumber} metadata changed during this session:\n\n${summary}`, { kind: 'metadata' });
+            await dispatchFrame(frame, { kind: 'metadata', label: `issue #${issueNumber} title/body` });
+            state.totalStatusFramesSent++;
+            state.lastIssueSnapshot = next;
+          }
+        }
+      }
+    }
+    // Uncommitted changes
+    if (tempDir) {
+      try {
+        const result = await $({ cwd: tempDir })`git status --porcelain 2>&1`;
+        if (result && result.code === 0) {
+          const out = (result.stdout?.toString() || '').trim();
+          const sig = `uncommitted::${out}`;
+          if (out && !state.statusSignatures.has(sig)) {
+            state.statusSignatures.add(sig);
+            const frame = formatFeedbackForClaude(`The local clone has uncommitted changes (git status --porcelain):\n\n${out}\n\nPlease either commit them (git add + git commit + git push) if they belong to the solution, or revert them (git checkout -- <file> or git clean -fd) otherwise.`, { kind: 'uncommitted' });
+            await dispatchFrame(frame, { kind: 'uncommitted', label: 'git status --porcelain' });
+            state.totalStatusFramesSent++;
+          }
+        }
+      } catch (error) {
+        if (verbose) {
+          await log(`⚠️ Bidirectional mode: Uncommitted-changes poll failed: ${error.message}`, { verbose: true });
+        }
+      }
+    }
+    // CI/CD blockers — only when we have prNumber + a working ./solve.auto-merge-helpers
+    if (prNumber) {
+      try {
+        const helpers = await import('./solve.auto-merge-helpers.lib.mjs');
+        if (helpers && typeof helpers.getMergeBlockers === 'function') {
+          const { blockers } = await helpers.getMergeBlockers(owner, repo, prNumber, false, 1, null);
+          for (const b of blockers || []) {
+            // Only stream actionable failures (not "ci_pending" or "ci_cancelled"
+            // — those don't need AI involvement and would be noise).
+            if (b.type !== 'ci_failure' && b.type !== 'not_mergeable') continue;
+            const sig = `ci::${b.type}::${(b.details && b.details[0]) || b.message}`;
+            if (state.statusSignatures.has(sig)) continue;
+            state.statusSignatures.add(sig);
+            const detailLines = (b.details || []).map(d => `  - ${d}`).join('\n');
+            const frame = formatFeedbackForClaude(`CI/CD blocker detected during this session: ${b.message}\n${detailLines || ''}\n\nPlease address the failing checks before continuing.`, { kind: 'ci' });
+            await dispatchFrame(frame, { kind: 'ci', label: b.message });
+            state.totalStatusFramesSent++;
+          }
+        }
+      } catch (error) {
+        if (verbose) {
+          await log(`⚠️ Bidirectional mode: CI status poll failed: ${error.message}`, { verbose: true });
+        }
+      }
+    }
+  };
+
   /**
    * Start monitoring PR comments for user feedback
    *
@@ -330,6 +605,29 @@ export const createBidirectionalHandler = options => {
     if (verbose) {
       await log(`🔌 Bidirectional mode: Started monitoring PR #${prNumber} (polling every ${interval / 1000}s)`, { verbose: true });
     }
+
+    // Issue #1708: When --auto-input-until-mergeable enables status streaming,
+    // start a parallel poller that watches CI/uncommitted/PR-metadata changes
+    // and emits NDJSON frames so the live AI session reacts to them without
+    // requiring an auto-restart.
+    if (streamStatusToInput) {
+      // Take an initial snapshot so the first real diff is meaningful.
+      if (prNumber) state.lastPrSnapshot = await fetchMetadataSnapshot('pr', prNumber);
+      if (issueNumber && issueNumber !== prNumber) state.lastIssueSnapshot = await fetchMetadataSnapshot('issue', issueNumber);
+      const statusInterval = Math.max(statusPollInterval, CONFIG.MIN_POLL_INTERVAL);
+      state.statusPollIntervalId = setInterval(async () => {
+        try {
+          await checkForStatusChanges();
+        } catch (error) {
+          if (verbose) {
+            await log(`⚠️ Bidirectional mode: Status poll error: ${error.message}`, { verbose: true });
+          }
+        }
+      }, statusInterval);
+      if (verbose) {
+        await log(`🔌 Bidirectional mode: Started status poller (CI/uncommitted/PR-metadata) every ${statusInterval / 1000}s`, { verbose: true });
+      }
+    }
   };
 
   /**
@@ -348,9 +646,13 @@ export const createBidirectionalHandler = options => {
       clearInterval(state.pollIntervalId);
       state.pollIntervalId = null;
     }
+    if (state.statusPollIntervalId) {
+      clearInterval(state.statusPollIntervalId);
+      state.statusPollIntervalId = null;
+    }
 
     if (verbose) {
-      await log(`🔌 Bidirectional mode: Stopped monitoring (processed ${state.totalCommentsProcessed} comments, queued ${state.totalFeedbackQueued} feedback)`, { verbose: true });
+      await log(`🔌 Bidirectional mode: Stopped monitoring (processed ${state.totalCommentsProcessed} comments, queued ${state.totalFeedbackQueued} feedback, ${state.totalStatusFramesSent} status frames)`, { verbose: true });
     }
   };
 
@@ -500,6 +802,14 @@ export const createBidirectionalHandler = options => {
     totalFeedbackQueued: state.totalFeedbackQueued,
     totalFeedbackStreamed: state.totalFeedbackStreamed,
     isStreamingAttached: !!state.claudeStdin,
+    // Issue #1708 additions
+    deliveryMode,
+    streamStatusToInput,
+    isAiBusy: state.isAiBusy,
+    pendingFramesLength: state.pendingFrames.length,
+    totalFramesQueued: state.totalFramesQueued,
+    totalFramesFlushed: state.totalFramesFlushed,
+    totalStatusFramesSent: state.totalStatusFramesSent,
   });
 
   return {
@@ -517,6 +827,10 @@ export const createBidirectionalHandler = options => {
     attachClaudeStdin,
     detachClaudeStdin,
     streamInitialPrompt,
+    // Issue #1708: queue mode + status streaming
+    markAiBusy,
+    markAiIdle,
+    checkForStatusChanges,
     getState,
     // Expose for testing
     _internal: {
@@ -526,6 +840,9 @@ export const createBidirectionalHandler = options => {
       formatFeedbackForClaude,
       buildInitialUserFrame,
       writeFrameToStdin,
+      dispatchFrame,
+      fetchMetadataSnapshot,
+      diffMetadataSnapshot,
     },
   };
 };
@@ -558,6 +875,27 @@ export const isBidirectionalModeSupported = tool => {
  * @returns {Promise<boolean>} Whether configuration is valid for the chosen tool
  */
 export const validateBidirectionalModeConfig = async (argv, log) => {
+  // Issue #1708 Stage 1: --auto-input-until-mergeable enables only the
+  // input-side of bidirectional mode — accepting incoming PR/issue comments
+  // as new input — without enabling --interactive-mode (which would push
+  // tool output back as PR comments). The full streaming-aware
+  // watchUntilMergeable replacement is staged in subsequent PRs — until
+  // those land, this composition gives users on --tool claude the
+  // mid-session NDJSON input pipe that already exists for issue #817 and
+  // is a graceful no-op for non-Claude tools (the validator below disables
+  // it). The --auto-restart-until-mergeable / --auto-resume loops remain
+  // active as fallbacks; the goal is for them to stay dormant when input
+  // streaming keeps the session alive.
+  if (argv.autoInputUntilMergeable) {
+    if (!argv.acceptIncommingCommentsAsInput) argv.acceptIncommingCommentsAsInput = true;
+    // Default delivery mode for --auto-input-until-mergeable is queue:
+    // hold comments until the AI is idle so the model can finish the
+    // current step before being interrupted.
+    if (!argv.streamCommentsToInput && !argv.queueCommentsToInput) {
+      argv.queueCommentsToInput = true;
+    }
+  }
+
   // Composition: --bidirectional-interactive-mode implies the three experimental flags.
   if (argv.bidirectionalInteractiveMode) {
     if (!argv.interactiveMode) argv.interactiveMode = true;
@@ -565,6 +903,19 @@ export const validateBidirectionalModeConfig = async (argv, log) => {
     if (!argv.excludeAllOwnIncommingCommentsFromInput) argv.excludeAllOwnIncommingCommentsFromInput = true;
   }
 
+  // Default delivery mode for --accept-incomming-comments-as-input on its
+  // own is stream (matches the existing #817 behavior of forwarding
+  // comments immediately as pollIncomingComments sees them).
+  if (argv.acceptIncommingCommentsAsInput && !argv.streamCommentsToInput && !argv.queueCommentsToInput) {
+    argv.streamCommentsToInput = true;
+  }
+
+  // queue mode wins if both delivery modes are set (defensive, in case the
+  // user passes both flags explicitly).
+  if (argv.queueCommentsToInput && argv.streamCommentsToInput) {
+    argv.streamCommentsToInput = false;
+  }
+
   // Nothing more to validate if no incoming-comment acceptance is requested
   if (!argv.acceptIncommingCommentsAsInput) return true;
 
@@ -574,11 +925,15 @@ export const validateBidirectionalModeConfig = async (argv, log) => {
     await log('   Incoming-comment acceptance will be disabled for this session.', { level: 'warning' });
     argv.acceptIncommingCommentsAsInput = false;
     argv.excludeAllOwnIncommingCommentsFromInput = false;
+    argv.streamCommentsToInput = false;
+    argv.queueCommentsToInput = false;
     return false;
   }
 
+  const deliveryMode = argv.queueCommentsToInput ? 'queue' : 'stream';
   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(`   delivery mode: ${deliveryMode}-comments-to-input`, { level: 'info' });
   await log('   PR comments will be monitored and queued as feedback for Claude.', { level: 'info' });
 
   return true;
@@ -591,34 +946,50 @@ export const validateBidirectionalModeConfig = async (argv, log) => {
  *
  * @param {Object} params
  * @param {Object} params.argv - Parsed CLI args (expects `acceptIncommingCommentsAsInput`,
- *   `excludeAllOwnIncommingCommentsFromInput`, `verbose`).
+ *   `excludeAllOwnIncommingCommentsFromInput`, `queueCommentsToInput`,
+ *   `streamCommentsToInput`, `autoInputUntilMergeable`, `verbose`).
  * @param {string} params.owner
  * @param {string} params.repo
  * @param {string|number} params.prNumber
+ * @param {string|number} [params.issueNumber] - Issue #1708: enables issue title/body polling
+ * @param {string} [params.tempDir] - Issue #1708: enables uncommitted-changes polling
  * @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 }) => {
+export const setupBidirectionalHandler = async ({ argv, owner, repo, prNumber, issueNumber, tempDir, $, 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;
   }
+  // Issue #1708: Resolve delivery mode from argv. validateBidirectionalModeConfig
+  // already enforces queue-wins-over-stream and the per-flag defaults; here we
+  // just translate the booleans into the handler-side enum.
+  const deliveryMode = argv.queueCommentsToInput ? 'queue' : 'stream';
+  // Issue #1708: Status streaming (CI/uncommitted/PR-metadata → NDJSON frames)
+  // is only enabled by --auto-input-until-mergeable; the standalone
+  // --accept-incomming-comments-as-input path keeps the existing #817 behavior
+  // of forwarding only comments.
+  const streamStatusToInput = !!argv.autoInputUntilMergeable;
   await log('🔌 Bidirectional mode: Creating handler to accept incoming PR comments as Claude input', { verbose: true });
   const handler = createBidirectionalHandler({
     owner,
     repo,
     prNumber,
+    issueNumber,
+    tempDir,
     $,
     log,
     verbose: argv.verbose,
     pollInterval: 15000,
     excludeOwnComments: !!argv.excludeAllOwnIncommingCommentsFromInput,
+    deliveryMode,
+    streamStatusToInput,
   });
   await handler.initializeFromCurrentComments();
   await handler.startMonitoring();
-  await log('🔌 Bidirectional mode: Started monitoring PR comments for feedback', { verbose: true });
+  await log(`🔌 Bidirectional mode: Started monitoring (delivery: ${deliveryMode}-comments-to-input${streamStatusToInput ? ', status streaming: on' : ''})`, { verbose: true });
   return handler;
 };