hungry-ghost-hive 0.52.2 → 0.54.0

package/src/cli/commands/manager/escalation-handler.test.ts

@@ -7,6 +7,7 @@ import {
   buildHumanApprovalReason,
   buildInterruptionRecoveryPrompt,
   buildRateLimitRecoveryPrompt,
+  extractQuestionContent,
   handleEscalationAndNudge,
 } from './escalation-handler.js';
 
@@ -28,12 +29,62 @@ vi.mock('../../../tmux/manager.js', () => ({
   getHiveSessions: vi.fn(),
   sendMessageWithConfirmation: vi.fn(),
   sendToTmuxSession: vi.fn(),
+  sendBtwToTmuxSession: vi.fn(),
   autoApprovePermission: vi.fn(),
   forceBypassMode: vi.fn(),
   isManagerRunning: vi.fn(),
   stopManager: vi.fn(),
 }));
 
+describe('extractQuestionContent', () => {
+  it('extracts lines above the interactive prompt as the question body', () => {
+    const output = [
+      'Some previous output',
+      '',
+      'Should I delete the existing migration files?',
+      'This will remove all local schema changes.',
+      '› Yes / No',
+    ].join('\n');
+
+    expect(extractQuestionContent(output)).toBe(
+      'Should I delete the existing migration files? This will remove all local schema changes.'
+    );
+  });
+
+  it('falls back to prompt line text when no lines precede the prompt', () => {
+    const output = '› Do you want to continue?';
+    expect(extractQuestionContent(output)).toBe('Do you want to continue?');
+  });
+
+  it('falls back to prompt line when preceding lines are empty', () => {
+    const output = '\n\n\n› Proceed with deployment?';
+    expect(extractQuestionContent(output)).toBe('Proceed with deployment?');
+  });
+
+  it('returns null when no interactive prompt line is found', () => {
+    const output = 'Agent is working on the task...';
+    expect(extractQuestionContent(output)).toBeNull();
+  });
+
+  it('strips the › prefix from the prompt line fallback', () => {
+    const output = '›  What branch should I use?';
+    expect(extractQuestionContent(output)).toBe('What branch should I use?');
+  });
+
+  it('handles > prefix as well as ›', () => {
+    const output = '> Run git push now?';
+    expect(extractQuestionContent(output)).toBe('Run git push now?');
+  });
+
+  it('stops collecting question lines at the first empty line above the prompt', () => {
+    const output = ['Old unrelated output', '', 'Question: should I proceed?', '› Yes / No'].join(
+      '\n'
+    );
+
+    expect(extractQuestionContent(output)).toBe('Question: should I proceed?');
+  });
+});
+
 describe('buildHumanApprovalReason', () => {
   it('should include option-2 guidance for codex permission menus', () => {
     const output = `
@@ -85,6 +136,40 @@ $ git restore --worktree
     expect(reason).toContain('Action: Answer the question in the agent session');
   });
 
+  it('extracts actual question text from terminal output for ASKING_QUESTION state', () => {
+    const output = [
+      'Some working output',
+      '',
+      'Should I overwrite the existing config file?',
+      '› Yes / No',
+    ].join('\n');
+
+    const reason = buildHumanApprovalReason(
+      'hive-junior-team-1',
+      'Asking a question - needs response',
+      AgentState.ASKING_QUESTION,
+      'claude',
+      output
+    );
+
+    expect(reason).toContain('Should I overwrite the existing config file?');
+    expect(reason).not.toContain('Asking a question - needs response');
+    expect(reason).toContain('Action: Answer the question in the agent session');
+  });
+
+  it('falls back to generic waitingReason when question extraction fails for ASKING_QUESTION', () => {
+    const reason = buildHumanApprovalReason(
+      'hive-junior-team-1',
+      'Asking a question - needs response',
+      AgentState.ASKING_QUESTION,
+      'claude',
+      'No interactive prompt here'
+    );
+
+    expect(reason).toContain('Asking a question - needs response');
+    expect(reason).toContain('Action: Answer the question in the agent session');
+  });
+
   it('should include recovery guidance for declined state', () => {
     const reason = buildHumanApprovalReason(
       'hive-senior-team-1',

package/src/cli/commands/manager/escalation-handler.ts

@@ -17,6 +17,7 @@ import {
   createManagerNudgeEnvelope,
   describeAgentState,
   isRateLimitPrompt,
+  sendBtwToTmuxSession,
   sendToTmuxSession,
   submitManagerNudgeWithVerification,
   type CLITool,
@@ -33,11 +34,51 @@ const rateLimitRecoveryAttempts = new Map<string, number>();
 const INTERRUPTION_PROMPT_PATTERN =
   /conversation interrupted|tell the model what to do differently|hit [`'"]?\/feedback[`'"]? to report the issue/i;
 const INTERRUPTION_WINDOW_LINES = 80;
+const QUESTION_EXTRACTION_WINDOW_LINES = 40;
+const INTERACTIVE_PROMPT_LINE_PATTERN = /^\s*(?:›|>)\s+\S.+$/m;
 
 function getRecentPaneOutput(output: string, lineCount: number): string {
   return output.split('\n').slice(-lineCount).join('\n');
 }
 
+export function extractQuestionContent(output: string): string | null {
+  const recentOutput = getRecentPaneOutput(output, QUESTION_EXTRACTION_WINDOW_LINES);
+  const lines = recentOutput.split('\n');
+
+  // Find the last interactive prompt line index
+  let promptLineIndex = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (INTERACTIVE_PROMPT_LINE_PATTERN.test(lines[i])) {
+      promptLineIndex = i;
+      break;
+    }
+  }
+
+  // Extract the prompt line text (strip leading › or > and whitespace)
+  const promptLine =
+    promptLineIndex >= 0 ? lines[promptLineIndex].replace(/^\s*(?:›|>)\s*/, '').trim() : null;
+
+  // Collect non-empty lines before the prompt as the question body
+  if (promptLineIndex > 0) {
+    const questionLines: string[] = [];
+    for (let i = promptLineIndex - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (line.length === 0) break;
+      questionLines.unshift(line);
+    }
+    if (questionLines.length > 0) {
+      return questionLines.join(' ');
+    }
+  }
+
+  // Fall back to the prompt line content itself
+  if (promptLine && promptLine.length > 0) {
+    return promptLine;
+  }
+
+  return null;
+}
+
 function isInterruptionPrompt(output: string): boolean {
   const recentOutput = getRecentPaneOutput(output, INTERRUPTION_WINDOW_LINES);
   return INTERRUPTION_PROMPT_PATTERN.test(recentOutput);
@@ -101,7 +142,14 @@ export function buildHumanApprovalReason(
   output: string
 ): string {
   const actionHint = getActionHintForBlockedState(state, cliTool, output);
-  return `Approval required (${cliTool}) in ${sessionName}: ${waitingReason || 'Unknown question'}. Action: ${actionHint}`;
+  let reason = waitingReason || 'Unknown question';
+  if (state === AgentState.ASKING_QUESTION) {
+    const extracted = extractQuestionContent(output);
+    if (extracted) {
+      reason = extracted;
+    }
+  }
+  return `Approval required (${cliTool}) in ${sessionName}: ${reason}. Action: ${actionHint}`;
 }
 
 export function buildInterruptionRecoveryPrompt(
@@ -415,33 +463,10 @@ export async function handleEscalationAndNudge(
     ctx.counters.escalationsCreated++;
     ctx.escalatedSessions.add(sessionName);
 
+    // Send auto-recovery reminder via /btw to avoid interrupting the agent
     const reminder = buildAutoRecoveryReminder(sessionName, agentCliTool);
-    const nudge = createManagerNudgeEnvelope(reminder);
-    await sendToTmuxSession(sessionName, nudge.text);
-    console.log(
-      chalk.gray(
-        `  Nudge ${nudge.nudgeId}: double-checking Enter delivery after nudge (verification loop enabled)`
-      )
-    );
-    const submitResult = await submitManagerNudgeWithVerification(sessionName, nudge.nudgeId);
-    ctx.counters.nudgeEnterPresses =
-      (ctx.counters.nudgeEnterPresses ?? 0) + submitResult.enterPresses;
-    ctx.counters.nudgeEnterRetries =
-      (ctx.counters.nudgeEnterRetries ?? 0) + submitResult.retryEnters;
-    if (!submitResult.confirmed) {
-      ctx.counters.nudgeSubmitUnconfirmed = (ctx.counters.nudgeSubmitUnconfirmed ?? 0) + 1;
-      console.log(
-        chalk.yellow(
-          `  Nudge ${nudge.nudgeId}: unable to confirm Enter delivery after ${submitResult.checks} check(s), ${submitResult.enterPresses} Enter keypress(es)`
-        )
-      );
-    } else {
-      console.log(
-        chalk.gray(
-          `  Nudge ${nudge.nudgeId}: Enter delivery confirmed after ${submitResult.checks} check(s), ${submitResult.enterPresses} Enter keypress(es)`
-        )
-      );
-    }
+    await sendBtwToTmuxSession(sessionName, reminder);
+    console.log(chalk.gray(`  Escalation nudge delivered via /btw to ${sessionName}`));
 
     console.log(chalk.red(`  ESCALATION: ${sessionName} needs human input`));
     verboseLog(ctx, `escalationCheck: ${sessionName} action=create_escalation`);

package/src/cli/commands/manager/handoff-recovery.ts

@@ -10,12 +10,7 @@ import { updateRequirement } from '../../../db/queries/requirements.js';
 import { getStoriesByStatus, updateStory } from '../../../db/queries/stories.js';
 import { isTmuxSessionRunning } from '../../../tmux/manager.js';
 import { getTechLeadSessionName } from '../../../utils/instance.js';
-import {
-  createManagerNudgeEnvelope,
-  sendToTmuxSession,
-  submitManagerNudgeWithVerification,
-  type CLITool,
-} from './agent-monitoring.js';
+import { sendBtwToTmuxSession, type CLITool } from './agent-monitoring.js';
 import type { ManagerCheckContext, PlanningHandoffTracking } from './types.js';
 import { PROACTIVE_HANDOFF_RETRY_DELAY_MS } from './types.js';
 
@@ -105,34 +100,9 @@ async function nudgeTechLeadForStalledHandoff(
 # Please move stories from estimated -> planned and run:
 # hive assign`;
 
-  const nudge = createManagerNudgeEnvelope(nudgeMessage);
-  await sendToTmuxSession(techLeadInfo.sessionName, nudge.text);
-  console.log(
-    chalk.gray(
-      `  Nudge ${nudge.nudgeId}: double-checking Enter delivery after nudge (verification loop enabled)`
-    )
-  );
-  const submitResult = await submitManagerNudgeWithVerification(
-    techLeadInfo.sessionName,
-    nudge.nudgeId
-  );
-  ctx.counters.nudgeEnterPresses =
-    (ctx.counters.nudgeEnterPresses ?? 0) + submitResult.enterPresses;
-  ctx.counters.nudgeEnterRetries = (ctx.counters.nudgeEnterRetries ?? 0) + submitResult.retryEnters;
-  if (!submitResult.confirmed) {
-    ctx.counters.nudgeSubmitUnconfirmed = (ctx.counters.nudgeSubmitUnconfirmed ?? 0) + 1;
-    console.log(
-      chalk.yellow(
-        `  Nudge ${nudge.nudgeId}: unable to confirm Enter delivery after ${submitResult.checks} check(s), ${submitResult.enterPresses} Enter keypress(es)`
-      )
-    );
-  } else {
-    console.log(
-      chalk.gray(
-        `  Nudge ${nudge.nudgeId}: Enter delivery confirmed after ${submitResult.checks} check(s), ${submitResult.enterPresses} Enter keypress(es)`
-      )
-    );
-  }
+  // Use /btw to deliver nudge non-interruptively
+  await sendBtwToTmuxSession(techLeadInfo.sessionName, nudgeMessage);
+  console.log(chalk.gray(`  Handoff nudge delivered via /btw to ${techLeadInfo.sessionName}`));
   verboseLog(
     ctx,
     `handoff: nudged tech-lead session=${techLeadInfo.sessionName} requirement=${requirementLabel} estimated=${estimatedCount}`

package/src/cli/commands/manager/index.test.ts

@@ -1,28 +1,51 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DatabaseProvider } from '../../../db/provider.js';
+import type { DatabaseProvider, WritableDatabaseProvider } from '../../../db/provider.js';
+import { getAllAgents } from '../../../db/queries/agents.js';
+import { getAllPendingMessages, markMessagesRead } from '../../../db/queries/messages.js';
 import { getApprovedPullRequests, updatePullRequest } from '../../../db/queries/pull-requests.js';
 
 // Mock the functions we're testing with
 vi.mock('../../../db/queries/pull-requests.js');
 vi.mock('../../../db/queries/stories.js');
 vi.mock('../../../db/queries/logs.js');
-vi.mock('../../../tmux/manager.js', () => ({
-  sendMessageWithConfirmation: vi.fn(),
-  getHiveSessions: vi.fn(),
-  sendToTmuxSession: vi.fn(),
-  sendEnterToTmuxSession: vi.fn(),
-  captureTmuxPane: vi.fn(),
-  isManagerRunning: vi.fn(),
-  stopManager: vi.fn(),
-  killTmuxSession: vi.fn(),
-}));
-vi.mock('../../../utils/cli-commands.js', () => ({
-  getAvailableCommands: vi.fn(() => ({
-    msgReply: (id: string, msg: string, session: string) =>
-      `hive msg reply ${id} "${msg}" --to ${session}`,
-  })),
+vi.mock('../../../db/queries/agents.js');
+vi.mock('../../../db/queries/messages.js');
+vi.mock('../../../tmux/manager.js', async importOriginal => {
+  const actual = await importOriginal<typeof import('../../../tmux/manager.js')>();
+  return {
+    ...actual,
+    sendMessageWithConfirmation: vi.fn(),
+    getHiveSessions: vi.fn(),
+    sendToTmuxSession: vi.fn(),
+    sendEnterToTmuxSession: vi.fn(),
+    captureTmuxPane: vi.fn(),
+    isManagerRunning: vi.fn(),
+    stopManager: vi.fn(),
+    killTmuxSession: vi.fn(),
+  };
+});
+vi.mock('../../../utils/cli-commands.js', async importOriginal => {
+  const actual = await importOriginal<typeof import('../../../utils/cli-commands.js')>();
+  return {
+    ...actual,
+    getAvailableCommands: vi.fn(() => ({
+      msgReply: (id: string, msg: string, session: string) =>
+        `hive msg reply ${id} "${msg}" --to ${session}`,
+    })),
+  };
+});
+vi.mock('./agent-monitoring.js', async importOriginal => {
+  const actual = await importOriginal<typeof import('./agent-monitoring.js')>();
+  return {
+    ...actual,
+    forwardMessages: vi.fn(),
+  };
+});
+vi.mock('../../../utils/with-hive-context.js', () => ({
+  withHiveContext: vi.fn(),
+  withHiveRoot: vi.fn(),
 }));
 
 describe('Auto-merge PRs', () => {
@@ -265,3 +288,113 @@ describe('Stuck reminder deferral', () => {
     expect(result).toBe(false);
   });
 });
+
+describe('runFastMessageCheck', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  function mockDbContext(save = vi.fn()) {
+    const provider = {} as WritableDatabaseProvider;
+    return {
+      db: {
+        provider,
+        save,
+        close: vi.fn(),
+        runMigrations: vi.fn(),
+        db: {} as never,
+      },
+      root: '/test',
+      paths: {} as never,
+    };
+  }
+
+  it('does nothing when there are no pending messages', async () => {
+    const { withHiveContext } = await import('../../../utils/with-hive-context.js');
+    const { forwardMessages } = await import('./agent-monitoring.js');
+
+    vi.mocked(withHiveContext).mockImplementation(async fn => fn(mockDbContext()));
+    vi.mocked(getAllPendingMessages).mockResolvedValue([]);
+
+    const { runFastMessageCheck } = await import('./index.js');
+    await runFastMessageCheck();
+
+    expect(forwardMessages).not.toHaveBeenCalled();
+    expect(markMessagesRead).not.toHaveBeenCalled();
+  });
+
+  it('forwards pending messages to target sessions', async () => {
+    const { withHiveContext } = await import('../../../utils/with-hive-context.js');
+    const { forwardMessages } = await import('./agent-monitoring.js');
+
+    const mockSave = vi.fn();
+    vi.mocked(withHiveContext).mockImplementation(async fn => fn(mockDbContext(mockSave)));
+
+    const pendingMessages = [
+      {
+        id: 'msg-1',
+        to_session: 'hive-agent-abc',
+        from_session: 'tech-lead',
+        subject: 'Test',
+        body: 'Hello',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        read_at: null,
+      },
+    ];
+    vi.mocked(getAllPendingMessages).mockResolvedValue(pendingMessages as never);
+    vi.mocked(getAllAgents).mockResolvedValue([
+      { id: 'agent-abc', tmux_session: null, cli_tool: 'claude' } as never,
+    ]);
+    vi.mocked(forwardMessages).mockResolvedValue(undefined);
+
+    const { runFastMessageCheck } = await import('./index.js');
+    await runFastMessageCheck();
+
+    expect(forwardMessages).toHaveBeenCalledWith('hive-agent-abc', pendingMessages, 'claude');
+    expect(markMessagesRead).toHaveBeenCalledWith(expect.anything(), ['msg-1']);
+    expect(mockSave).toHaveBeenCalled();
+  });
+
+  it('uses claude as default cli_tool when agent not found', async () => {
+    const { withHiveContext } = await import('../../../utils/with-hive-context.js');
+    const { forwardMessages } = await import('./agent-monitoring.js');
+
+    vi.mocked(withHiveContext).mockImplementation(async fn => fn(mockDbContext()));
+
+    const pendingMessages = [
+      {
+        id: 'msg-2',
+        to_session: 'unknown-session',
+        from_session: 'user',
+        subject: null,
+        body: 'Hi',
+        status: 'pending',
+        created_at: new Date().toISOString(),
+        read_at: null,
+      },
+    ];
+    vi.mocked(getAllPendingMessages).mockResolvedValue(pendingMessages as never);
+    vi.mocked(getAllAgents).mockResolvedValue([]);
+    vi.mocked(forwardMessages).mockResolvedValue(undefined);
+
+    const { runFastMessageCheck } = await import('./index.js');
+    await runFastMessageCheck();
+
+    expect(forwardMessages).toHaveBeenCalledWith('unknown-session', pendingMessages, 'claude');
+  });
+
+  it('does not trigger full agent scan (scanAgentSessions not called)', async () => {
+    const { withHiveContext } = await import('../../../utils/with-hive-context.js');
+    const { getHiveSessions } = await import('../../../tmux/manager.js');
+
+    vi.mocked(withHiveContext).mockImplementation(async fn => fn(mockDbContext()));
+    vi.mocked(getAllPendingMessages).mockResolvedValue([]);
+
+    const { runFastMessageCheck } = await import('./index.js');
+    await runFastMessageCheck();
+
+    // Full scan would call getHiveSessions — verify it is not called
+    expect(getHiveSessions).not.toHaveBeenCalled();
+  });
+});

package/src/cli/commands/manager/index.ts

@@ -353,6 +353,13 @@ managerCommand
         setInterval(() => {
           void runCheck();
         }, slowInterval);
+
+        // Fast message-check path: forward pending messages without full agent scan
+        const messagePollInterval = config.manager.message_poll_interval_ms;
+        console.log(chalk.gray(`  Fast message polling every ${messagePollInterval / 1000}s`));
+        setInterval(() => {
+          void runFastMessageCheck(verbose);
+        }, messagePollInterval);
       } else if (releaseLock) {
         await releaseLock();
         if (clusterRuntime) {
@@ -518,6 +525,58 @@ managerCommand
     });
   });
 
+export async function runFastMessageCheck(verbose = false): Promise<void> {
+  verboseLog(verbose, 'fastMessageCheck: start');
+  try {
+    await withHiveContext(async ({ db }) => {
+      const allPendingMessages = await getAllPendingMessages(db.provider);
+      if (allPendingMessages.length === 0) {
+        verboseLog(verbose, 'fastMessageCheck: no pending messages');
+        return;
+      }
+
+      verboseLog(verbose, `fastMessageCheck: ${allPendingMessages.length} pending message(s)`);
+
+      const messagesBySession = new Map<string, typeof allPendingMessages>();
+      for (const msg of allPendingMessages) {
+        if (!messagesBySession.has(msg.to_session)) {
+          messagesBySession.set(msg.to_session, []);
+        }
+        messagesBySession.get(msg.to_session)!.push(msg);
+      }
+
+      const allAgents = await getAllAgents(db.provider);
+      const agentBySession = new Map<string, AgentRow>();
+      for (const agent of allAgents) {
+        agentBySession.set(`hive-${agent.id}`, agent);
+        if (agent.tmux_session) {
+          agentBySession.set(agent.tmux_session, agent);
+        }
+      }
+
+      const forwardedIds: string[] = [];
+      for (const [sessionName, messages] of messagesBySession) {
+        const agent = agentBySession.get(sessionName);
+        const cliTool: CLITool = (agent?.cli_tool as CLITool) || 'claude';
+        verboseLog(
+          verbose,
+          `fastMessageCheck: forwarding ${messages.length} message(s) to ${sessionName}`
+        );
+        await forwardMessages(sessionName, messages, cliTool);
+        forwardedIds.push(...messages.map(m => m.id));
+      }
+
+      if (forwardedIds.length > 0) {
+        markMessagesRead(db.provider, forwardedIds);
+        db.save();
+        verboseLog(verbose, `fastMessageCheck: marked ${forwardedIds.length} message(s) as read`);
+      }
+    });
+  } catch (err) {
+    verboseLog(verbose, `fastMessageCheck: error ${String(err)}`);
+  }
+}
+
 async function managerCheck(
   root: string,
   config?: HiveConfig,

package/src/cli/commands/manager/manager-utils.ts

@@ -2,11 +2,7 @@
 
 import chalk from 'chalk';
 import type { HiveConfig } from '../../../config/schema.js';
-import { sendToTmuxSession } from '../../../tmux/manager.js';
-import {
-  createManagerNudgeEnvelope,
-  submitManagerNudgeWithVerification,
-} from './agent-monitoring.js';
+import { sendBtwToTmuxSession } from '../../../tmux/manager.js';
 import type { ManagerCheckContext } from './types.js';
 
 const DEFAULT_SCREEN_STATIC_INACTIVITY_THRESHOLD_MS = 10 * 60 * 1000;
@@ -30,43 +26,14 @@ export function formatDuration(ms: number): string {
   return `${minutes}m ${seconds}s`;
 }
 
-async function submitManagerNudge(
-  ctx: ManagerCheckContext,
-  sessionName: string,
-  nudgeId: string
-): Promise<void> {
-  console.log(
-    chalk.gray(
-      `  Nudge ${nudgeId}: double-checking Enter delivery after nudge (verification loop enabled)`
-    )
-  );
-  const result = await submitManagerNudgeWithVerification(sessionName, nudgeId);
-  ctx.counters.nudgeEnterPresses = (ctx.counters.nudgeEnterPresses ?? 0) + result.enterPresses;
-  ctx.counters.nudgeEnterRetries = (ctx.counters.nudgeEnterRetries ?? 0) + result.retryEnters;
-  if (!result.confirmed) {
-    ctx.counters.nudgeSubmitUnconfirmed = (ctx.counters.nudgeSubmitUnconfirmed ?? 0) + 1;
-    console.log(
-      chalk.yellow(
-        `  Nudge ${nudgeId}: unable to confirm Enter delivery after ${result.checks} check(s), ${result.enterPresses} Enter keypress(es)`
-      )
-    );
-    return;
-  }
-  console.log(
-    chalk.gray(
-      `  Nudge ${nudgeId}: Enter delivery confirmed after ${result.checks} check(s), ${result.enterPresses} Enter keypress(es)`
-    )
-  );
-}
-
 export async function sendManagerNudge(
-  ctx: ManagerCheckContext,
+  _ctx: ManagerCheckContext,
   sessionName: string,
   message: string
 ): Promise<void> {
-  const envelope = createManagerNudgeEnvelope(message);
-  await sendToTmuxSession(sessionName, envelope.text);
-  await submitManagerNudge(ctx, sessionName, envelope.nudgeId);
+  // Use /btw for non-interrupting nudge delivery
+  await sendBtwToTmuxSession(sessionName, message);
+  console.log(chalk.gray(`  Nudge delivered via /btw to ${sessionName}`));
 }
 
 export function getScreenStaticInactivityThresholdMs(config?: HiveConfig): number {

package/src/config/schema.ts

@@ -250,6 +250,8 @@ const ManagerConfigSchema = z.object({
   auditor_interval_ms: z.number().int().positive().default(300000),
   // Whether auditor agent is enabled (false falls back to nudge behavior)
   auditor_enabled: z.boolean().default(true),
+  // Fast message poll interval for web UI interactions (ms, default 10s)
+  message_poll_interval_ms: z.number().int().positive().default(10000),
 });
 
 // Merge queue configuration
@@ -573,6 +575,8 @@ manager:
   auditor_interval_ms: 300000
   # Whether auditor agent is enabled (false falls back to nudge behavior)
   auditor_enabled: true
+  # Fast message poll interval for web UI interactions (ms, default 10s)
+  message_poll_interval_ms: 10000
 
 # Merge queue configuration
 merge_queue:

package/src/context-files/index.test.ts

@@ -228,6 +228,7 @@ describe('context-files module', () => {
         tech_lead_max_age_hours: 6,
         auditor_interval_ms: 300000,
         auditor_enabled: true,
+        message_poll_interval_ms: 10000,
       },
       logging: { level: 'info', retention_days: 30 },
       cluster: {

package/src/tmux/manager.test.ts

@@ -68,6 +68,55 @@ describe('sendMessageWithConfirmation', () => {
   });
 });
 
+describe('sendBtwToTmuxSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should be exported as a function', async () => {
+    const { sendBtwToTmuxSession } = await import('./manager.js');
+    expect(typeof sendBtwToTmuxSession).toBe('function');
+  });
+
+  it('should have the expected function signature', async () => {
+    const { sendBtwToTmuxSession } = await import('./manager.js');
+    const sig = sendBtwToTmuxSession.toString();
+    expect(sig).toContain('sessionName');
+    expect(sig).toContain('message');
+  });
+
+  it('should prefix messages with /btw', async () => {
+    const { sendBtwToTmuxSession } = await import('./manager.js');
+    const sig = sendBtwToTmuxSession.toString();
+    expect(sig).toContain('/btw ');
+  });
+
+  it('should not clear input before sending', async () => {
+    const { sendBtwToTmuxSession } = await import('./manager.js');
+    const sig = sendBtwToTmuxSession.toString();
+    // Should NOT contain Escape or C-u clearing logic
+    expect(sig).not.toContain('Escape');
+    expect(sig).not.toContain('C-u');
+  });
+
+  it('should handle multi-line messages via paste buffer', async () => {
+    const { sendBtwToTmuxSession } = await import('./manager.js');
+    const sig = sendBtwToTmuxSession.toString();
+    expect(sig).toContain('set-buffer');
+    expect(sig).toContain('paste-buffer');
+  });
+
+  it('should send Enter after the message', async () => {
+    const { sendBtwToTmuxSession } = await import('./manager.js');
+    const sig = sendBtwToTmuxSession.toString();
+    expect(sig).toContain('C-m');
+  });
+});
+
 describe('tmux shell command hardening', () => {
   it('shellEscapeArg should safely escape single quotes', async () => {
     const { shellEscapeArg } = await import('./manager.js');