@link-assistant/hive-mind 2.1.2 → 2.1.4

package/src/limits.lib.mjs

@@ -14,7 +14,7 @@ import utc from 'dayjs/plugin/utc.js';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
 import { formatLimitResetsAt, formatLimitResetsIn, formatLocalizedCurrentTime, formatLocalizedRelativeTime, formatLocalizedResetTime, localizeCompactDuration, lt, resolveLimitLocale } from './limits-i18n.lib.mjs';
-import { formatSubscriptionLines, getCachedClaudeSubscription, getCachedCodexSubscription, getClaudeSubscriptionInfo, getCodexSubscriptionInfo } from './limits-subscription.lib.mjs';
+import { formatSubscriptionHeading, formatSubscriptionLines, getCachedClaudeSubscription, getCachedCodexSubscription, getClaudeSubscriptionInfo, getCodexSubscriptionInfo } from './limits-subscription.lib.mjs';
 export { getCachedClaudeSubscription, getCachedCodexSubscription, getClaudeSubscriptionInfo, getCodexSubscriptionInfo };
 // Initialize dayjs plugins
 dayjs.extend(utc);
@@ -280,6 +280,61 @@ function getLocalizedRelativeReset(window, options = {}, fallbackRelative = null
   return formatRelativeTime(window?.resetsAt, options) || localizeCompactDuration(fallbackRelative, options);
 }
 
+function formatCodeBlock(content) {
+  const text = Array.isArray(content) ? content.join('\n') : String(content ?? '');
+  return '```\n' + (text.endsWith('\n') ? text : `${text}\n`) + '```';
+}
+
+function formatPlainTitledCodeSection(section) {
+  const text = String(section ?? '').trimEnd();
+  if (!text) return '';
+  if (text.includes('```')) return text;
+
+  const lines = text.split('\n');
+  const title = lines.shift();
+  const body = lines.join('\n');
+  if (!body) return formatCodeBlock(title);
+  return `${title}\n\n${formatCodeBlock(body)}`;
+}
+
+function formatLimitWindowSection(label, window, periodHours, threshold, options = {}) {
+  const locale = resolveLimitLocale(options);
+  let section = `${label}\n`;
+  if (hasLimitPercentage(window)) {
+    const timePassed = calculateTimePassedPercentage(window.resetsAt, periodHours);
+    if (timePassed !== null) {
+      section += `${getProgressBar(timePassed)} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
+    }
+
+    const pct = Math.floor(window.percentage);
+    const bar = getProgressBar(pct, threshold);
+    const suffix = pct >= threshold ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
+    section += `${bar} ${pct}%${suffix}\n`;
+
+    const resetTime = getLocalizedResetTime(window, { locale });
+    if (resetTime) {
+      const relativeTime = getLocalizedRelativeReset(window, { locale });
+      section += relativeTime ? `${formatLimitResetsIn(relativeTime, resetTime, { locale })}\n` : `${formatLimitResetsAt(resetTime, { locale })}\n`;
+    }
+  } else {
+    section += `${lt('na', {}, { locale })}\n`;
+  }
+  return section;
+}
+
+function hasPositivePercentage(value) {
+  if (value === null || value === undefined) return false;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && numeric > 0;
+}
+
+function hasPositiveCreditBalance(credits) {
+  if (!credits) return false;
+  if (credits.unlimited) return true;
+  const numeric = Number.parseFloat(String(credits.balance ?? '0'));
+  return Number.isFinite(numeric) && numeric > 0;
+}
+
 /**
  * Get GitHub API rate limits by calling gh api rate_limit
  * Returns rate limit info for core, search, graphql, and other resources
@@ -1061,118 +1116,51 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
     sections.push(section);
   }
 
-  // Claude limits section
-  // When there's an error (e.g., auth expired), show it once and skip empty subsections
+  const claudeHeading = formatSubscriptionHeading('claude', subscription, { locale });
+  const useShortClaudeLabels = Boolean(claudeHeading);
+  const claudeSections = [];
+
+  // Claude limits section. When there's an error (e.g., auth expired), show it once and skip empty subsections.
   if (claudeError) {
-    sections.push(`${lt('claude_limits', {}, { locale })}\n${claudeError}\n`);
+    claudeSections.push(useShortClaudeLabels ? `${claudeError}\n` : `${lt('claude_limits', {}, { locale })}\n${claudeError}\n`);
   } else {
-    // Claude 5 hour session (five_hour)
-    // Threshold: One-at-a-time mode when usage >= 65%
-    let sessionSection = `${lt('claude_5_hour_session', {}, { locale })}\n`;
-    if (hasLimitPercentage(usage?.currentSession)) {
-      const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
-      if (timePassed !== null) {
-        const timeBar = getProgressBar(timePassed);
-        sessionSection += `${timeBar} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
-      }
-
-      // Use Math.floor so 100% only appears when usage is exactly 100%
-      // See: https://github.com/link-assistant/hive-mind/issues/1133
-      const pct = Math.floor(usage.currentSession.percentage);
-      const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION);
-      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
-      sessionSection += `${bar} ${pct}%${suffix}\n`;
-
-      const sessionResetTime = getLocalizedResetTime(usage.currentSession, { locale });
-      if (sessionResetTime) {
-        const relativeTime = getLocalizedRelativeReset(usage.currentSession, { locale });
-        if (relativeTime) {
-          sessionSection += `${formatLimitResetsIn(relativeTime, sessionResetTime, { locale })}\n`;
-        } else {
-          sessionSection += `${formatLimitResetsAt(sessionResetTime, { locale })}\n`;
-        }
-      }
-    } else {
-      sessionSection += `${lt('na', {}, { locale })}\n`;
+    const hasSonnetOnly = hasLimitPercentage(usage?.sonnetOnly);
+    claudeSections.push(formatLimitWindowSection(useShortClaudeLabels ? lt('five_hour_limit_session', {}, { locale }) : lt('claude_5_hour_session', {}, { locale }), usage?.currentSession, 5, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION, { locale }));
+    claudeSections.push(formatLimitWindowSection(useShortClaudeLabels && !hasSonnetOnly ? lt('current_week', {}, { locale }) : lt('current_week_all_models', {}, { locale }), usage?.allModels, 168, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY, { locale }));
+    if (hasSonnetOnly || !useShortClaudeLabels) {
+      claudeSections.push(formatLimitWindowSection(lt('current_week_sonnet_only', {}, { locale }), usage?.sonnetOnly, 168, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY, { locale }));
     }
-    sections.push(sessionSection);
-
-    // Current week (all models / seven_day)
-    // Threshold: One-at-a-time mode when usage >= 97%
-    let allModelsSection = `${lt('current_week_all_models', {}, { locale })}\n`;
-    if (hasLimitPercentage(usage?.allModels)) {
-      const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
-      if (timePassed !== null) {
-        const timeBar = getProgressBar(timePassed);
-        allModelsSection += `${timeBar} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
-      }
 
-      // Use Math.floor so 100% only appears when usage is exactly 100%
-      // See: https://github.com/link-assistant/hive-mind/issues/1133
-      const pct = Math.floor(usage.allModels.percentage);
-      const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
-      allModelsSection += `${bar} ${pct}%${suffix}\n`;
-
-      const allModelsResetTime = getLocalizedResetTime(usage.allModels, { locale });
-      if (allModelsResetTime) {
-        const relativeTime = getLocalizedRelativeReset(usage.allModels, { locale });
-        if (relativeTime) {
-          allModelsSection += `${formatLimitResetsIn(relativeTime, allModelsResetTime, { locale })}\n`;
-        } else {
-          allModelsSection += `${formatLimitResetsAt(allModelsResetTime, { locale })}\n`;
-        }
-      }
-    } else {
-      allModelsSection += `${lt('na', {}, { locale })}\n`;
+    if (!useShortClaudeLabels) {
+      const subscriptionLines = formatSubscriptionLines(subscription, { locale });
+      if (subscriptionLines) claudeSections.push(subscriptionLines);
     }
-    sections.push(allModelsSection);
-
-    // Current week (Sonnet only / seven_day_sonnet)
-    // Threshold: One-at-a-time mode when usage >= 97% (same as all models)
-    let sonnetSection = `${lt('current_week_sonnet_only', {}, { locale })}\n`;
-    if (hasLimitPercentage(usage?.sonnetOnly)) {
-      // Add time passed progress bar first (no threshold marker for time)
-      const timePassed = calculateTimePassedPercentage(usage.sonnetOnly.resetsAt, 168);
-      if (timePassed !== null) {
-        const timeBar = getProgressBar(timePassed);
-        sonnetSection += `${timeBar} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
-      }
+  }
 
-      // Add usage progress bar second with threshold marker
-      // Use Math.floor so 100% only appears when usage is exactly 100%
-      // See: https://github.com/link-assistant/hive-mind/issues/1133
-      const pct = Math.floor(usage.sonnetOnly.percentage);
-      const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
-      sonnetSection += `${bar} ${pct}%${suffix}\n`;
-
-      const sonnetResetTime = getLocalizedResetTime(usage.sonnetOnly, { locale });
-      if (sonnetResetTime) {
-        const relativeTime = getLocalizedRelativeReset(usage.sonnetOnly, { locale });
-        if (relativeTime) {
-          sonnetSection += `${formatLimitResetsIn(relativeTime, sonnetResetTime, { locale })}\n`;
-        } else {
-          sonnetSection += `${formatLimitResetsAt(sonnetResetTime, { locale })}\n`;
-        }
-      }
-    } else {
-      sonnetSection += `${lt('na', {}, { locale })}\n`;
+  const hasFencedExtraSection = extraSections.some(extra => String(extra ?? '').includes('```'));
+  const useSplitLayout = Boolean(claudeHeading) || hasFencedExtraSection;
+
+  if (!useSplitLayout) {
+    sections.push(...claudeSections);
+    for (const extra of extraSections) {
+      sections.push(extra);
     }
-    sections.push(sonnetSection);
+    return formatCodeBlock(sections.join('\n'));
+  }
 
-    const subscriptionLines = formatSubscriptionLines(subscription, { locale });
-    if (subscriptionLines) sections.push(subscriptionLines);
+  const markdownSections = [];
+  markdownSections.push(formatCodeBlock(claudeHeading ? sections.join('\n') : [...sections, ...claudeSections].join('\n')));
+  if (claudeHeading) {
+    markdownSections.push(claudeHeading);
+    markdownSections.push(formatCodeBlock(claudeSections.join('\n')));
   }
 
-  // Append any caller-provided extra sections (e.g. queue status) inside the code block
   for (const extra of extraSections) {
-    sections.push(extra);
+    const formatted = formatPlainTitledCodeSection(extra);
+    if (formatted) markdownSections.push(formatted);
   }
 
-  // Wrap all sections in a single code block for monospace font / aligned progress bars.
-  // Sections are separated by blank lines; the trailing newline on each section provides spacing.
-  return '```\n' + sections.join('\n') + '```';
+  return markdownSections.join('\n\n');
 }
 
 /**
@@ -1185,64 +1173,33 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
  */
 export function formatCodexLimitsSection(codexLimits, codexError = null, options = {}) {
   const locale = resolveLimitLocale(options);
-  if (codexError) {
-    return `${lt('codex_limits', {}, { locale })}\n${codexError}\n`;
-  }
-
+  const subscription = options?.subscription || null;
   const usage = codexLimits?.usage || null;
   const additionalRateLimits = codexLimits?.additionalRateLimits || [];
   const credits = codexLimits?.credits || null;
-  const planType = codexLimits?.planType || null;
-  const subscription = options?.subscription || null;
+  const planType = subscription?.planType || codexLimits?.planType || null;
+  const heading = formatSubscriptionHeading('codex', subscription, { locale, planType });
+  const useTitledLayout = Boolean(heading);
 
-  let section = `${lt('codex_limits', {}, { locale })}\n`;
-  if (planType) {
-    section += `${lt('plan', {}, { locale })}: ${planType}\n`;
+  if (codexError) {
+    const errorSection = useTitledLayout ? `${codexError}\n` : `${lt('codex_limits', {}, { locale })}\n${codexError}\n`;
+    return useTitledLayout ? `${heading}\n\n${formatCodeBlock(errorSection)}` : errorSection;
   }
 
-  let sessionSection = `${lt('codex_5_hour_session', {}, { locale })}\n`;
-  if (hasLimitPercentage(usage?.currentSession)) {
-    const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
-    if (timePassed !== null) {
-      sessionSection += `${getProgressBar(timePassed)} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
-    }
-    const pct = Math.floor(usage.currentSession.percentage);
-    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
-    sessionSection += `${bar} ${pct}%${suffix}\n`;
-    const sessionResetTime = getLocalizedResetTime(usage.currentSession, { locale });
-    if (sessionResetTime) {
-      const relativeTime = getLocalizedRelativeReset(usage.currentSession, { locale });
-      sessionSection += relativeTime ? `${formatLimitResetsIn(relativeTime, sessionResetTime, { locale })}\n` : `${formatLimitResetsAt(sessionResetTime, { locale })}\n`;
-    }
-  } else {
-    sessionSection += `${lt('na', {}, { locale })}\n`;
+  let section = useTitledLayout ? '' : `${lt('codex_limits', {}, { locale })}\n`;
+  if (planType && !useTitledLayout) {
+    section += `${lt('plan', {}, { locale })}: ${planType}\n`;
   }
 
-  let weeklySection = `${lt('current_week_all_models', {}, { locale })}\n`;
-  if (hasLimitPercentage(usage?.allModels)) {
-    const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
-    if (timePassed !== null) {
-      weeklySection += `${getProgressBar(timePassed)} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
-    }
-    const pct = Math.floor(usage.allModels.percentage);
-    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CODEX_WEEKLY);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_WEEKLY ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
-    weeklySection += `${bar} ${pct}%${suffix}\n`;
-    const weeklyResetTime = getLocalizedResetTime(usage.allModels, { locale });
-    if (weeklyResetTime) {
-      const relativeTime = getLocalizedRelativeReset(usage.allModels, { locale });
-      weeklySection += relativeTime ? `${formatLimitResetsIn(relativeTime, weeklyResetTime, { locale })}\n` : `${formatLimitResetsAt(weeklyResetTime, { locale })}\n`;
-    }
-  } else {
-    weeklySection += `${lt('na', {}, { locale })}\n`;
-  }
+  const sessionSection = formatLimitWindowSection(useTitledLayout ? lt('five_hour_limit_session', {}, { locale }) : lt('codex_5_hour_session', {}, { locale }), usage?.currentSession, 5, DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION, { locale });
+  const weeklySection = formatLimitWindowSection(useTitledLayout ? lt('current_week', {}, { locale }) : lt('current_week_all_models', {}, { locale }), usage?.allModels, 168, DISPLAY_THRESHOLDS.CODEX_WEEKLY, { locale });
 
   section += `${sessionSection}\n${weeklySection}`;
 
-  if (additionalRateLimits.length > 0) {
+  const visibleAdditionalRateLimits = additionalRateLimits.filter(limit => hasPositivePercentage(limit.allModels?.percentage));
+  if (visibleAdditionalRateLimits.length > 0) {
     section += `\n${lt('additional_codex_limits', {}, { locale })}\n`;
-    for (const limit of additionalRateLimits) {
+    for (const limit of visibleAdditionalRateLimits) {
       const sessionPct = limit.currentSession?.percentage;
       const weeklyPct = limit.allModels?.percentage;
       const sessionText = sessionPct === null || sessionPct === undefined ? `${lt('session', {}, { locale })} ${lt('na', {}, { locale })}` : `${lt('session', {}, { locale })} ${Math.floor(sessionPct)}%`;
@@ -1251,15 +1208,17 @@ export function formatCodexLimitsSection(codexLimits, codexError = null, options
     }
   }
 
-  if (credits) {
+  if (hasPositiveCreditBalance(credits)) {
     const creditSummary = credits.unlimited ? lt('unlimited', {}, { locale }) : `${credits.balance ?? '0'} ${lt('balance', {}, { locale })}`;
     section += `\n${lt('codex_credits', {}, { locale })}\n${creditSummary}\n`;
   }
 
-  const subscriptionLines = formatSubscriptionLines(subscription, { locale });
-  if (subscriptionLines) section += subscriptionLines;
+  if (!useTitledLayout) {
+    const subscriptionLines = formatSubscriptionLines(subscription, { locale });
+    if (subscriptionLines) section += subscriptionLines;
+  }
 
-  return section;
+  return useTitledLayout ? `${heading}\n\n${formatCodeBlock(section)}` : section;
 }
 
 // ============================================================================

package/src/live-input-capabilities.lib.mjs

@@ -0,0 +1,221 @@
+/**
+ * Shared capability matrix for live issue/PR event input.
+ *
+ * Issue #2007 asks solve to feed issue/PR events into the running AI tool "in
+ * all ways possible", and to provide a universal fallback for every tool that
+ * does not have a mid-session live input channel: wait for the current turn to
+ * finish in the JSON output, stop the process, and resume the AI session with
+ * the new events.
+ *
+ * Because of that fallback, live event input is *available* for every tool.
+ * Tools differ only in the delivery `mode`:
+ *
+ *   - `stream`  : the tool exposes a live stdin/JSON channel, so new events are
+ *                 written into the running process without restarting it. Claude
+ *                 and Agent (`--input-format stream-json`) are wired for this today.
+ *   - `fallback`: no verified mid-session input channel exists yet, so solve uses
+ *                 the restart/resume loop (`--auto-restart-until-mergeable` /
+ *                 `watchUntilMergeable`). It waits for the current session to end,
+ *                 then resumes/restarts the AI with the new issue/PR events as
+ *                 feedback. This works for every tool.
+ *
+ * Missing native live-input features for each tool are reported upstream in the
+ * https://github.com/link-assistant/agent repository so they can be implemented
+ * (see `agentIssue`), after which a tool can graduate from `fallback` to `stream`.
+ */
+
+export const ISSUE_2007_REQUIRED_EVENT_IDS = Object.freeze(['issue-title', 'issue-body', 'issue-comments', 'pull-request-comments']);
+
+export const LIVE_INPUT_EVENT_SOURCES = Object.freeze([
+  Object.freeze({
+    id: 'issue-title',
+    label: 'Issue title updates',
+    requiredByIssue2007: true,
+    note: 'User-facing issue metadata should be streamed when it changes during a run.',
+  }),
+  Object.freeze({
+    id: 'issue-body',
+    label: 'Issue description updates',
+    requiredByIssue2007: true,
+    note: 'The issue body is treated as user feedback because it can change after the agent starts.',
+  }),
+  Object.freeze({
+    id: 'issue-comments',
+    label: 'Issue comments',
+    requiredByIssue2007: true,
+    note: 'New non-system issue comments are user feedback.',
+  }),
+  Object.freeze({
+    id: 'pull-request-comments',
+    label: 'Pull request comments',
+    requiredByIssue2007: true,
+    note: 'New non-system PR conversation comments and review comments should reach the agent.',
+  }),
+  Object.freeze({
+    id: 'pull-request-description',
+    label: 'Pull request description updates',
+    requiredByIssue2007: false,
+    note: 'Issue #2007 explicitly treats the PR description as AI-owned, so it is not a required user-feedback source.',
+  }),
+]);
+
+const REQUIRED_EVENTS = ISSUE_2007_REQUIRED_EVENT_IDS;
+
+// Delivery modes for live issue/PR event input.
+export const LIVE_INPUT_MODE_STREAM = 'stream';
+export const LIVE_INPUT_MODE_FALLBACK = 'fallback';
+
+// Shared description of the universal restart/resume fallback so every tool
+// entry reports it identically.
+const FALLBACK_DESCRIPTION = 'Universal fallback: wait for the current AI turn to finish in the JSON output, stop the process, then resume/restart the AI session with the new issue/PR events as feedback via --auto-restart-until-mergeable (watchUntilMergeable). Works for every tool even without a live stdin channel.';
+
+const CAPABILITIES = Object.freeze({
+  claude: Object.freeze({
+    tool: 'claude',
+    label: 'Claude',
+    available: true,
+    mode: LIVE_INPUT_MODE_STREAM,
+    liveStreaming: true,
+    supported: true,
+    option: '--auto-input-until-mergeable',
+    protocol: 'claude --input-format stream-json stdin NDJSON',
+    currentRunner: 'src/claude.lib.mjs keeps stdin as a pipe and attaches bidirectional-interactive.lib.mjs',
+    futureProtocol: '',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: '',
+    unsupportedReason: '',
+    testing: 'Run solve with --tool claude --auto-input-until-mergeable, add an issue or PR comment while the Claude process is alive, and watch for the bidirectional handler to queue or stream a user frame into stdin.',
+  }),
+  codex: Object.freeze({
+    tool: 'codex',
+    label: 'Codex',
+    available: true,
+    mode: LIVE_INPUT_MODE_FALLBACK,
+    liveStreaming: false,
+    supported: false,
+    option: '--auto-input-until-mergeable',
+    protocol: 'Restart/resume fallback (no live stdin wired through solve for Codex yet).',
+    currentRunner: 'src/codex.lib.mjs uses codex exec with prompt/stdin context at process start',
+    futureProtocol: 'Codex app-server JSON-RPC turn/steer',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: 'https://github.com/link-assistant/agent/issues',
+    unsupportedReason: 'The current solve Codex runner uses codex exec, whose stdin is one-shot prompt/context at process start. It does not expose a live JSON input pipe for mid-session issue/PR events, so the restart/resume fallback is used. Codex app-server turn/steer is the candidate protocol for a future live-streaming Codex runner.',
+    testing: 'Passing --tool codex --auto-input-until-mergeable activates the restart/resume fallback: the run finishes the current session, then resumes with the new issue/PR events.',
+  }),
+  agent: Object.freeze({
+    tool: 'agent',
+    label: 'Agent',
+    available: true,
+    mode: LIVE_INPUT_MODE_STREAM,
+    liveStreaming: true,
+    supported: true,
+    option: '--auto-input-until-mergeable',
+    protocol: 'agent --input-format stream-json --output-format stream-json stdin/stdout NDJSON',
+    currentRunner: 'src/agent.lib.mjs keeps stdin as a pipe and attaches bidirectional-interactive.lib.mjs when live input is enabled',
+    futureProtocol: '',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: 'https://github.com/link-assistant/agent/pull/274',
+    unsupportedReason: '',
+    testing: 'Run solve with --tool agent --auto-input-until-mergeable, add an issue or PR comment while the Agent process is alive, and watch for the bidirectional handler to queue or stream a user frame into stdin.',
+  }),
+  opencode: Object.freeze({
+    tool: 'opencode',
+    label: 'OpenCode',
+    available: true,
+    mode: LIVE_INPUT_MODE_FALLBACK,
+    liveStreaming: false,
+    supported: false,
+    option: '--auto-input-until-mergeable',
+    protocol: 'Restart/resume fallback (no live JSON input channel wired through solve for OpenCode yet).',
+    currentRunner: 'src/opencode.lib.mjs uses a prompt-via-file/stdin pattern',
+    futureProtocol: '',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: 'https://github.com/link-assistant/agent/issues',
+    unsupportedReason: 'No verified live JSON input channel is wired through solve for OpenCode yet, so the restart/resume fallback is used.',
+    testing: 'Passing --tool opencode --auto-input-until-mergeable activates the restart/resume fallback.',
+  }),
+  gemini: Object.freeze({
+    tool: 'gemini',
+    label: 'Gemini',
+    available: true,
+    mode: LIVE_INPUT_MODE_FALLBACK,
+    liveStreaming: false,
+    supported: false,
+    option: '--auto-input-until-mergeable',
+    protocol: 'Restart/resume fallback (no live JSON input channel wired through solve for Gemini yet).',
+    currentRunner: 'src/gemini.lib.mjs uses a prompt-driven process invocation',
+    futureProtocol: '',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: 'https://github.com/link-assistant/agent/issues',
+    unsupportedReason: 'No verified live JSON input channel is wired through solve for Gemini yet, so the restart/resume fallback is used.',
+    testing: 'Passing --tool gemini --auto-input-until-mergeable activates the restart/resume fallback.',
+  }),
+  qwen: Object.freeze({
+    tool: 'qwen',
+    label: 'Qwen',
+    available: true,
+    mode: LIVE_INPUT_MODE_FALLBACK,
+    liveStreaming: false,
+    supported: false,
+    option: '--auto-input-until-mergeable',
+    protocol: 'Restart/resume fallback (no live JSON input channel wired through solve for Qwen yet).',
+    currentRunner: 'src/qwen.lib.mjs uses a prompt-driven process invocation',
+    futureProtocol: '',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: 'https://github.com/link-assistant/agent/issues',
+    unsupportedReason: 'No verified live JSON input channel is wired through solve for Qwen yet, so the restart/resume fallback is used.',
+    testing: 'Passing --tool qwen --auto-input-until-mergeable activates the restart/resume fallback.',
+  }),
+});
+
+const UNKNOWN_CAPABILITY = tool =>
+  Object.freeze({
+    tool,
+    label: tool,
+    available: true,
+    mode: LIVE_INPUT_MODE_FALLBACK,
+    liveStreaming: false,
+    supported: false,
+    option: '--auto-input-until-mergeable',
+    protocol: 'Restart/resume fallback (no live JSON input channel wired through solve for this tool yet).',
+    currentRunner: 'Unknown or custom solve tool runner',
+    futureProtocol: '',
+    fallback: FALLBACK_DESCRIPTION,
+    events: REQUIRED_EVENTS,
+    agentIssue: 'https://github.com/link-assistant/agent/issues',
+    unsupportedReason: `No verified live JSON input channel is wired through solve for ${tool}, so the restart/resume fallback is used. Add a live-input capability entry (and report the missing native API to link-assistant/agent) once the runner has a long-lived stdin, JSON-RPC, or SDK channel that accepts new user turns mid-session.`,
+    testing: 'The flag activates the restart/resume fallback until a live-streaming runner is implemented.',
+  });
+
+export const getLiveInputCapability = tool => {
+  const normalizedTool = String(tool || '')
+    .trim()
+    .toLowerCase();
+  return CAPABILITIES[normalizedTool] || UNKNOWN_CAPABILITY(normalizedTool || 'unknown');
+};
+
+/**
+ * Whether the tool has a live *streaming* input channel (writes events into the
+ * running process). Kept as `isLiveInputSupported` for backward compatibility;
+ * it is the stream-mode predicate, not "is live input available at all".
+ */
+export const isLiveInputSupported = tool => getLiveInputCapability(tool).mode === LIVE_INPUT_MODE_STREAM;
+
+/**
+ * Whether live issue/PR event input is available for the tool in *any* mode
+ * (streaming or restart/resume fallback). This is true for every tool.
+ */
+export const isLiveInputAvailable = tool => getLiveInputCapability(tool).available === true;
+
+/**
+ * Resolve the delivery mode ('stream' or 'fallback') for a tool.
+ */
+export const getLiveInputMode = tool => getLiveInputCapability(tool).mode;
+
+export const getLiveInputCapabilityRows = () => Object.values(CAPABILITIES);

package/src/locales/en.lino

@@ -192,6 +192,11 @@ en
         hour
           session "Claude 5 hour session"
       limits "Claude limits"
+      subscription
+        title "Claude{{plan}} subscription"
+    chatgpt
+      subscription
+        title "ChatGPT{{plan}} subscription"
     codex
       5
         hour
@@ -205,6 +210,7 @@ en
     current
       time "Current time"
       week
+        label "Current week"
         all
           models "Current week (all models)"
         sonnet
@@ -226,6 +232,8 @@ en
     end "End"
     five
       hour
+        limit
+          session "5 hour session"
         session "5h session"
       min
         load
@@ -314,6 +322,14 @@ en
     session "session"
     start "Start"
     subscription
+      detail
+        ends
+          label "ends {{time}}"
+          in "ends in {{duration}}; {{time}}"
+        trial
+          ends
+            label "trial ends {{time}}"
+            in "trial ends in {{duration}}; {{time}}"
       ends
         label "Subscription ends {{time}}"
         in "Subscription ends in {{duration}} ({{time}})"

package/src/locales/hi.lino

@@ -192,6 +192,11 @@ hi
         hour
           session "Claude 5 घंटे का सत्र"
       limits "Claude सीमाएँ"
+      subscription
+        title "Claude{{plan}} सदस्यता"
+    chatgpt
+      subscription
+        title "ChatGPT{{plan}} सदस्यता"
     codex
       5
         hour
@@ -205,6 +210,7 @@ hi
     current
       time "वर्तमान समय"
       week
+        label "वर्तमान सप्ताह"
         all
           models "वर्तमान सप्ताह (सभी मॉडल)"
         sonnet
@@ -226,6 +232,8 @@ hi
     end "समाप्ति"
     five
       hour
+        limit
+          session "5 घंटे का सत्र"
         session "5 घंटे का सत्र"
       min
         load
@@ -314,6 +322,14 @@ hi
     session "सत्र"
     start "शुरुआत"
     subscription
+      detail
+        ends
+          label "{{time}} को समाप्त होगी"
+          in "{{duration}} में समाप्त होगी; {{time}}"
+        trial
+          ends
+            label "ट्रायल {{time}} को समाप्त होगा"
+            in "ट्रायल {{duration}} में समाप्त होगा; {{time}}"
       ends
         label "सदस्यता समाप्त होगी {{time}}"
         in "सदस्यता {{duration}} में समाप्त होगी ({{time}})"