@chrisromp/copilot-bridge 0.9.2 → 0.10.0

package/dist/index.js

@@ -12,6 +12,7 @@ import { initScheduler, stopAll as stopScheduler, listJobs, removeJob, pauseJob,
 import { markBusy, markIdle, markIdleImmediate, isBusy, waitForChannelIdle, cancelIdleDebounce } from './core/channel-idle.js';
 import { LoopDetector, MAX_IDENTICAL_CALLS } from './core/loop-detector.js';
 import { checkUserAccess } from './core/access-control.js';
+import { enterQuietMode, exitQuietMode, isQuiet } from './core/quiet-mode.js';
 import { createLogger, setLogLevel } from './logger.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -30,8 +31,9 @@ const ACTIVITY_THROTTLE_MS = 600;
 const channelLocks = new Map();
 // Per-channel promise chain to serialize SESSION EVENT handling (prevents race on auto-start)
 const eventLocks = new Map();
-// Channels with an active startup nudge in flight (NO_REPLY filter only applies here)
-const nudgePending = new Set();
+// Channels in "quiet mode" — all streaming output suppressed until we determine
+// whether the response is NO_REPLY. Used for startup nudges and scheduled tasks.
+// State managed in src/core/quiet-mode.ts
 // Bot adapters keyed by "platform:botName" for channel→adapter lookup
 const botAdapters = new Map();
 const botStreamers = new Map();
@@ -39,6 +41,8 @@ const botStreamers = new Map();
 const loopDetector = new LoopDetector();
 // Track last known sessionId per channel for implicit session change detection
 const lastSessionIds = new Map();
+// Channels that have had their plan surfaced after session resume (one-time)
+const planSurfacedOnResume = new Set();
 /** Format a date as a relative age string (e.g., "2h ago", "3d ago"). */
 function formatAge(date) {
     const ms = Date.now() - new Date(date).getTime();
@@ -57,6 +61,70 @@ function formatAge(date) {
 function sanitizeFilename(name) {
     return name.replace(/[/\\]/g, '_').replace(/\.\./g, '_');
 }
+/** Max message size per platform. Conservative defaults — Slack blocks are 3000 but we allow some overhead. */
+function getMaxMessageLength(platform) {
+    switch (platform) {
+        case 'slack': return 3500;
+        case 'mattermost': return 16000;
+        default: return 4000;
+    }
+}
+/**
+ * Split content into chunks that fit within a platform's message size limit.
+ * Splits at heading boundaries (## ) when possible, otherwise at line boundaries.
+ */
+function chunkContent(content, maxLen) {
+    if (content.length <= maxLen)
+        return [content];
+    const lines = content.split('\n');
+    const chunks = [];
+    let current = [];
+    let currentLen = 0;
+    for (const line of lines) {
+        const lineLen = line.length + 1; // +1 for newline
+        // Start new chunk at ## heading if adding this line would exceed limit
+        if (line.startsWith('## ') && current.length > 0 && currentLen + lineLen > maxLen) {
+            chunks.push(current.join('\n'));
+            current = [line];
+            currentLen = lineLen;
+        }
+        else if (currentLen + lineLen > maxLen && current.length > 0) {
+            // Mid-section split at line boundary
+            chunks.push(current.join('\n'));
+            current = [line];
+            currentLen = lineLen;
+        }
+        else {
+            current.push(line);
+            currentLen += lineLen;
+        }
+    }
+    if (current.length > 0)
+        chunks.push(current.join('\n'));
+    // Safety: hard-truncate any chunk that still exceeds maxLen (e.g. single very long line)
+    return chunks.map(c => c.length > maxLen ? c.slice(0, maxLen - 3) + '...' : c);
+}
+/** Send content that may exceed platform message limits, chunking with part labels as needed. */
+async function sendChunked(adapter, channelId, content, platform, opts) {
+    const maxLen = getMaxMessageLength(platform);
+    const header = opts?.header ? opts.header + '\n\n' : '';
+    const headerLen = header.length;
+    // Try to fit in one message
+    if (headerLen + content.length <= maxLen) {
+        await adapter.sendMessage(channelId, header + content, { threadRootId: opts?.threadRootId });
+        return;
+    }
+    // Chunk the content (reserve space for part label + header in first chunk)
+    const labelReserve = 30; // "_(Part XX of XX)_\n"
+    const effectiveMax = maxLen - labelReserve - headerLen;
+    const chunks = chunkContent(content, effectiveMax);
+    const total = chunks.length;
+    for (let i = 0; i < chunks.length; i++) {
+        const label = total > 1 ? `_(Part ${i + 1} of ${total})_\n` : '';
+        const prefix = i === 0 ? header : '';
+        await adapter.sendMessage(channelId, prefix + label + chunks[i].trim(), { threadRootId: opts?.threadRootId });
+    }
+}
 /** Download message attachments to .temp/<channelId>/ in the bot's workspace, returning SDK-compatible attachment objects. */
 async function downloadAttachments(attachments, channelId, adapter) {
     if (!attachments || attachments.length === 0)
@@ -368,7 +436,7 @@ async function main() {
                 handleMidTurnMessage(msg, sessionManager, platformName, botName)
                     .catch(err => {
                     // Expected fallbacks — debug level
-                    const expected = err?.message === 'slash-command-while-busy' || err?.message === 'file-only-while-busy';
+                    const expected = err?.message === 'slash-command-while-busy' || err?.message === 'attachments-while-busy';
                     if (expected) {
                         log.debug(`Mid-turn fallback (${err.message}), routing to normal handler`);
                     }
@@ -431,7 +499,8 @@ async function main() {
                 const resolved = getAdapterForChannel(channelId);
                 if (resolved) {
                     const { streaming } = resolved;
-                    // Atomically swap streams via eventLocks to prevent event interleaving
+                    // Finalize any existing stream, but don't create a new one —
+                    // quiet mode defers stream creation until we know the response isn't NO_REPLY
                     const evPrev = eventLocks.get(channelId) ?? Promise.resolve();
                     const evTask = evPrev.then(async () => {
                         const existingStream = activeStreams.get(channelId);
@@ -439,13 +508,13 @@ async function main() {
                             await streaming.finalizeStream(existingStream);
                             activeStreams.delete(channelId);
                         }
-                        const streamKey = await streaming.startStream(channelId);
-                        activeStreams.set(channelId, streamKey);
                     });
                     eventLocks.set(channelId, evTask.catch(() => { }));
                     await evTask;
                     markBusy(channelId);
                 }
+                // Enter quiet mode — suppresses all streaming until NO_REPLY determination
+                const clearQuiet = enterQuietMode(channelId);
                 try {
                     await sessionManager.sendMessage(channelId, prompt);
                     // Hold the lock until the response is fully streamed
@@ -463,6 +532,9 @@ async function main() {
                     }
                     throw err;
                 }
+                finally {
+                    clearQuiet();
+                }
             });
             channelLocks.set(channelId, task.catch(() => { }));
             await task;
@@ -604,6 +676,8 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
             channelThreadRoots.delete(msg.channelId);
             await finalizeActivityFeed(msg.channelId, adapter);
             await sessionManager.abortSession(msg.channelId);
+            // Revert yolo if temporarily enabled for plan implementation
+            sessionManager.revertYoloIfNeeded(msg.channelId);
             markIdleImmediate(msg.channelId);
             await adapter.sendMessage(msg.channelId, '🛑 Task stopped.', { threadRootId: threadRoot });
             return;
@@ -617,11 +691,17 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
             channelThreadRoots.delete(msg.channelId);
             await finalizeActivityFeed(msg.channelId, adapter);
             loopDetector.reset(msg.channelId);
+            planSurfacedOnResume.delete(msg.channelId);
             await sessionManager.newSession(msg.channelId);
             markIdleImmediate(msg.channelId);
             await adapter.sendMessage(msg.channelId, '✅ New session created.', { threadRootId: threadRoot });
             return;
         }
+        // Messages with attachments can't steer — queue them for normal processing
+        // where downloadAttachments runs and files are passed to the SDK
+        if (msg.attachments?.length) {
+            throw new Error('attachments-while-busy');
+        }
         // Read-only / toggle commands — safe to handle mid-turn
         // Only commands where handleCommand returns a complete response (no separate action rendering).
         // Commands with complex action handlers (skills, schedule, rules) defer to serialized path.
@@ -661,10 +741,6 @@ async function handleMidTurnMessage(msg, sessionManager, platformName, botName)
         // All other slash commands — defer to serialized path
         throw new Error('slash-command-while-busy');
     }
-    // File-only messages can't steer — queue them for normal processing
-    if (!text && msg.attachments?.length) {
-        throw new Error('file-only-while-busy');
-    }
     log.info(`Mid-turn steering for ${msg.channelId.slice(0, 8)}...: "${text.slice(0, 100)}"`);
     // Atomically swap streams via eventLocks so no residual events from the
     // previous response can sneak in between finalization and the new stream.
@@ -876,6 +952,19 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                     }
                     const resumedId = await sessionManager.resumeToSession(msg.channelId, matches[0]);
                     await adapter.updateMessage(msg.channelId, resumeAck, `✅ Resumed session \`${resumedId.slice(0, 8)}…\``);
+                    // Surface existing plan after resume — only when in plan mode
+                    try {
+                        const mode = await sessionManager.getSessionMode(msg.channelId);
+                        if (mode === 'plan') {
+                            const plan = await sessionManager.readPlan(msg.channelId);
+                            if (plan.exists && plan.content) {
+                                planSurfacedOnResume.add(msg.channelId);
+                                const summary = sessionManager.extractPlanSummary(plan.content);
+                                await adapter.sendMessage(msg.channelId, `📋 **Existing plan found** — ${summary}. \`/plan show\` to review, \`/plan clear\` to discard.`, { threadRootId: threadRoot });
+                            }
+                        }
+                    }
+                    catch { /* plan surfacing is best-effort */ }
                 }
                 catch (err) {
                     await adapter.updateMessage(msg.channelId, resumeAck, `❌ Failed to resume session: ${err?.message ?? 'unknown error'}`);
@@ -1287,21 +1376,54 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                             await adapter.sendMessage(msg.channelId, '📋 No plan exists for this session.', { threadRootId: threadRoot });
                         }
                         else {
-                            const truncated = plan.content.length > 3500 ? plan.content.slice(0, 3500) + '\n\n_…truncated_' : plan.content;
-                            await adapter.sendMessage(msg.channelId, `📋 **Current Plan**\n\n${truncated}`, { threadRootId: threadRoot });
+                            await sendChunked(adapter, msg.channelId, plan.content, channelConfig.platform, {
+                                threadRootId: threadRoot,
+                                header: '📋 **Current Plan**',
+                            });
                         }
                     }
                     else if (subcommand === 'clear' || subcommand === 'delete') {
                         const deleted = await sessionManager.deletePlan(msg.channelId);
                         await adapter.sendMessage(msg.channelId, deleted ? '📋 Plan cleared.' : '📋 No plan to clear.', { threadRootId: threadRoot });
                     }
+                    else if (subcommand === 'summary') {
+                        // Ensure session is attached (handles post-restart state)
+                        const currentMode = await sessionManager.getSessionMode(msg.channelId);
+                        await sessionManager.setSessionMode(msg.channelId, currentMode ?? 'interactive');
+                        const plan = await sessionManager.readPlan(msg.channelId);
+                        if (!plan.exists || !plan.content) {
+                            await adapter.sendMessage(msg.channelId, '📋 No plan exists for this session.', { threadRootId: threadRoot });
+                        }
+                        else {
+                            // Ephemeral session summarization — doesn't pollute main conversation
+                            await adapter.sendMessage(msg.channelId, '📋 Summarizing plan...', { threadRootId: threadRoot });
+                            const summary = await sessionManager.summarizePlan(msg.channelId);
+                            if (summary) {
+                                await adapter.sendMessage(msg.channelId, `📋 **Plan summary:**\n\n${summary}\n\n\`/plan show\` to view the full plan.`, { threadRootId: threadRoot });
+                            }
+                            else {
+                                // Fallback to structural extraction if ephemeral session fails
+                                const fallback = sessionManager.extractPlanSummary(plan.content);
+                                await adapter.sendMessage(msg.channelId, `📋 ${fallback}\n\n\`/plan show\` to view the full plan.`, { threadRootId: threadRoot });
+                            }
+                        }
+                    }
                     else if (subcommand === 'off') {
                         await sessionManager.setSessionMode(msg.channelId, 'interactive');
                         await adapter.sendMessage(msg.channelId, '📋 **Plan mode off** — back to interactive mode.', { threadRootId: threadRoot });
                     }
                     else if (subcommand === 'on') {
+                        // Set mode first (ensures session is attached after restart), then check for existing plan
                         await sessionManager.setSessionMode(msg.channelId, 'plan');
-                        await adapter.sendMessage(msg.channelId, '📋 **Plan mode on** — messages will be handled as planning requests. The agent will create and update a plan before implementing.\n\nUse `/plan show` to view the plan, `/plan` to toggle off.', { threadRootId: threadRoot });
+                        const existingPlan = await sessionManager.readPlan(msg.channelId);
+                        planSurfacedOnResume.add(msg.channelId);
+                        if (existingPlan.exists && existingPlan.content) {
+                            const summary = sessionManager.extractPlanSummary(existingPlan.content);
+                            await adapter.sendMessage(msg.channelId, `📋 **Existing plan found** — ${summary}\n\n\`/plan show\` to review the full plan.\n\`/plan clear\` to discard and start fresh.\n\nEntering plan mode with existing plan.`, { threadRootId: threadRoot });
+                        }
+                        else {
+                            await adapter.sendMessage(msg.channelId, '📋 **Plan mode on** — messages will be handled as planning requests. The agent will create and update a plan before implementing.\n\nUse `/plan show` to view the plan, `/plan` to toggle off.', { threadRootId: threadRoot });
+                        }
                     }
                     else if (!subcommand) {
                         // Toggle: check current mode and flip
@@ -1311,12 +1433,21 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                             await adapter.sendMessage(msg.channelId, '📋 **Plan mode off** — back to interactive mode.', { threadRootId: threadRoot });
                         }
                         else {
+                            // Set mode first (ensures session is attached after restart), then check for existing plan
                             await sessionManager.setSessionMode(msg.channelId, 'plan');
-                            await adapter.sendMessage(msg.channelId, '📋 **Plan mode on** — messages will be handled as planning requests. The agent will create and update a plan before implementing.\n\nUse `/plan show` to view the plan, `/plan` to toggle off.', { threadRootId: threadRoot });
+                            const existingPlan = await sessionManager.readPlan(msg.channelId);
+                            planSurfacedOnResume.add(msg.channelId);
+                            if (existingPlan.exists && existingPlan.content) {
+                                const summary = sessionManager.extractPlanSummary(existingPlan.content);
+                                await adapter.sendMessage(msg.channelId, `📋 **Existing plan found** — ${summary}\n\n\`/plan show\` to review the full plan.\n\`/plan clear\` to discard and start fresh.\n\nEntering plan mode with existing plan.`, { threadRootId: threadRoot });
+                            }
+                            else {
+                                await adapter.sendMessage(msg.channelId, '📋 **Plan mode on** — messages will be handled as planning requests. The agent will create and update a plan before implementing.\n\nUse `/plan show` to view the plan, `/plan` to toggle off.', { threadRootId: threadRoot });
+                            }
                         }
                     }
                     else {
-                        await adapter.sendMessage(msg.channelId, '⚠️ Usage: `/plan` (toggle), `/plan show`, `/plan clear`, `/plan on`, `/plan off`', { threadRootId: threadRoot });
+                        await adapter.sendMessage(msg.channelId, '⚠️ Usage: `/plan` (toggle), `/plan show`, `/plan summary`, `/plan clear`, `/plan on`, `/plan off`', { threadRootId: threadRoot });
                     }
                 }
                 catch (err) {
@@ -1325,6 +1456,66 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
                 }
                 break;
             }
+            case 'implement': {
+                try {
+                    const arg = cmdResult.payload?.toLowerCase();
+                    const enableYolo = arg === 'yolo';
+                    const interactive = arg === 'interactive';
+                    // Set mode first (ensures session is attached after restart).
+                    // For interactive, this is a no-op on mode; for autopilot, we revert below if no plan.
+                    const targetMode = interactive ? 'interactive' : 'autopilot';
+                    await sessionManager.setSessionMode(msg.channelId, targetMode);
+                    // Now read plan (session is guaranteed to be attached)
+                    const plan = await sessionManager.readPlan(msg.channelId);
+                    if (!plan.exists || !plan.content) {
+                        // Revert mode back to interactive if we set autopilot
+                        if (!interactive)
+                            await sessionManager.setSessionMode(msg.channelId, 'interactive');
+                        await adapter.sendMessage(msg.channelId, '📋 No plan exists. Create one first with `/plan on`.', { threadRootId: threadRoot });
+                        break;
+                    }
+                    // Save yolo state before changing it
+                    if (enableYolo) {
+                        sessionManager.saveYoloPreviousState(msg.channelId);
+                        setChannelPrefs(msg.channelId, { permissionMode: 'autopilot' });
+                    }
+                    const modeLabel = interactive ? 'interactive' : enableYolo ? 'autopilot + yolo' : 'autopilot';
+                    await adapter.sendMessage(msg.channelId, `🚀 **Implementing plan** (${modeLabel})`, { threadRootId: threadRoot });
+                    // Clear pending plan exit if one was waiting
+                    sessionManager.consumePendingPlanExit(msg.channelId);
+                    // Set up stream and hold channel lock (matches regular message flow)
+                    const evPrev = eventLocks.get(msg.channelId) ?? Promise.resolve();
+                    const evTask = evPrev.then(async () => {
+                        const existingStreamKey = activeStreams.get(msg.channelId);
+                        if (existingStreamKey) {
+                            await streaming.finalizeStream(existingStreamKey);
+                            activeStreams.delete(msg.channelId);
+                        }
+                        initialStreamPosted.add(msg.channelId);
+                        const streamKey = await streaming.startStream(msg.channelId, threadRoot);
+                        activeStreams.set(msg.channelId, streamKey);
+                    });
+                    eventLocks.set(msg.channelId, evTask.catch(() => { }));
+                    await evTask;
+                    markBusy(msg.channelId);
+                    // Send plan content as a synthetic message to kick off implementation
+                    const kickoff = `Implement the following plan:\n\n${plan.content}`;
+                    await sessionManager.sendMessage(msg.channelId, kickoff);
+                    await waitForChannelIdle(msg.channelId);
+                }
+                catch (err) {
+                    sessionManager.revertYoloIfNeeded(msg.channelId);
+                    markIdleImmediate(msg.channelId);
+                    const sk = activeStreams.get(msg.channelId);
+                    if (sk) {
+                        await streaming.cancelStream(sk);
+                        activeStreams.delete(msg.channelId);
+                    }
+                    log.error(`Failed to handle /implement on ${msg.channelId.slice(0, 8)}...:`, err);
+                    await adapter.sendMessage(msg.channelId, `❌ Failed: ${err?.message ?? 'unknown error'}`, { threadRootId: threadRoot });
+                }
+                break;
+            }
             case 'toggle_autopilot': {
                 try {
                     const current = await sessionManager.getSessionMode(msg.channelId);
@@ -1370,6 +1561,10 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
         // Unrecognized text — auto-deny and fall through to process as a normal message
         sessionManager.resolvePermission(msg.channelId, false);
     }
+    // Pending plan exit — auto-dismiss on unrecognized text, process message normally
+    if (sessionManager.hasPendingPlanExit(msg.channelId)) {
+        sessionManager.consumePendingPlanExit(msg.channelId);
+    }
     // Regular message — forward to Copilot session
     try {
         // Check auth before starting a session (prevents hanging on "Working...")
@@ -1418,6 +1613,16 @@ async function handleInboundMessage(msg, sessionManager, platformName, botName)
             return;
         }
         await sessionManager.sendMessage(msg.channelId, prompt, sdkAttachments.length > 0 ? sdkAttachments : undefined, msg.userId);
+        // One-time plan surfacing after session resume — only when in plan mode (best-effort, non-blocking)
+        if (!planSurfacedOnResume.has(msg.channelId)) {
+            planSurfacedOnResume.add(msg.channelId);
+            sessionManager.surfacePlanIfExists(msg.channelId).then(async (result) => {
+                if (result?.exists && result.inPlanMode) {
+                    const threadRootForPlan = channelThreadRoots.get(msg.channelId);
+                    await adapter.sendMessage(msg.channelId, `📋 **Existing plan found** — ${result.summary}. \`/plan show\` to review.`, { threadRootId: threadRootForPlan });
+                }
+            }).catch(() => { });
+        }
         // Hold the channelLock until session.idle so queued work (scheduler, etc.)
         // doesn't start a new stream while this response is still being streamed.
         await waitForChannelIdle(msg.channelId);
@@ -1524,7 +1729,14 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
     const prefs = getChannelPrefs(channelId);
     const verbose = prefs?.verbose ?? channelConfig.verbose;
     // Handle custom bridge events (permissions, user input)
+    // During quiet mode, auto-deny permissions and suppress input requests —
+    // quiet tasks should be non-interactive
     if (event.type === 'bridge.permission_request') {
+        if (isQuiet(channelId)) {
+            log.info(`Auto-denying permission during quiet mode on ${channelId.slice(0, 8)}...`);
+            sessionManager.resolvePermission(channelId, false);
+            return;
+        }
         const streamKey = activeStreams.get(channelId);
         const threadRootId = streamKey ? streaming.getStreamThreadRootId(streamKey) : undefined;
         if (threadRootId)
@@ -1540,6 +1752,11 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
         return;
     }
     if (event.type === 'bridge.user_input_request') {
+        if (isQuiet(channelId)) {
+            log.info(`Suppressing user input request during quiet mode on ${channelId.slice(0, 8)}...`);
+            sessionManager.resolveUserInput(channelId, '');
+            return;
+        }
         const streamKey = activeStreams.get(channelId);
         const threadRootId = streamKey ? streaming.getStreamThreadRootId(streamKey) : undefined;
         if (threadRootId)
@@ -1554,24 +1771,111 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
         await adapter.sendMessage(channelId, formatted, { threadRootId });
         return;
     }
+    // Handle plan_changed events — debounced summary surfacing
+    if (event.type === 'session.plan_changed') {
+        const operation = event.data?.operation;
+        if (operation === 'create' || operation === 'update') {
+            sessionManager.debouncePlanChanged(channelId, async () => {
+                try {
+                    const plan = await sessionManager.readPlan(channelId);
+                    if (!plan.exists || !plan.content)
+                        return;
+                    const summary = sessionManager.extractPlanSummary(plan.content);
+                    const threadRootId = channelThreadRoots.get(channelId);
+                    await adapter.sendMessage(channelId, `📋 **Plan updated** — ${summary}. \`/plan show\` for details.`, { threadRootId });
+                }
+                catch (err) {
+                    log.warn(`Failed to surface plan summary: ${err}`);
+                }
+            });
+        }
+        return;
+    }
+    // Handle exit_plan_mode.requested — present implementation options
+    if (event.type === 'exit_plan_mode.requested') {
+        const { requestId, summary, planContent, actions, recommendedAction } = event.data;
+        const streamKey = activeStreams.get(channelId);
+        const threadRootId = streamKey ? streaming.getStreamThreadRootId(streamKey) : undefined;
+        if (threadRootId)
+            channelThreadRoots.set(channelId, threadRootId);
+        if (streamKey) {
+            await streaming.finalizeStream(streamKey);
+            activeStreams.delete(channelId);
+        }
+        await finalizeActivityFeed(channelId, adapter);
+        sessionManager.setPendingPlanExit(channelId, {
+            requestId,
+            summary: summary ?? '',
+            planContent: planContent ?? '',
+            actions: actions ?? [],
+            recommendedAction: recommendedAction ?? '',
+            createdAt: Date.now(),
+        });
+        const msg = [
+            '📋 **Plan ready**',
+            '',
+            summary || '(no summary provided)',
+            '',
+            'How would you like to proceed?',
+            '1. ▶️ `/implement yolo` — autopilot + yolo (fully autonomous)',
+            '2. 🚀 `/implement` — autopilot (with permission prompts)',
+            '3. 🔧 `/implement interactive` — interactive mode',
+            '4. ❌ `/plan off` — exit plan mode without implementing',
+            '',
+            'Or just keep chatting to continue refining the plan.',
+        ].join('\n');
+        await adapter.sendMessage(channelId, msg, { threadRootId });
+        return;
+    }
     // Format and route SDK events
     const formatted = formatEvent(event);
     if (!formatted)
         return;
-    // Filter out NO_REPLY responses from startup nudges only
-    if (nudgePending.has(channelId) && formatted.type === 'content' && event.type === 'assistant.message') {
-        const content = formatted.content?.trim();
-        nudgePending.delete(channelId);
-        if (content === 'NO_REPLY' || content === '`NO_REPLY`') {
-            log.info(`Filtered NO_REPLY from nudge on channel ${channelId.slice(0, 8)}...`);
-            // Clean up any active stream without posting
-            const sk = activeStreams.get(channelId);
-            if (sk) {
-                await streaming.deleteStream(sk);
-                activeStreams.delete(channelId);
+    // ── Quiet mode: suppress all output until we know if response is NO_REPLY ──
+    if (isQuiet(channelId)) {
+        // Suppress content events (deltas and messages)
+        if (formatted.type === 'content') {
+            if (event.type === 'assistant.message_delta') {
+                return;
+            }
+            if (event.type === 'assistant.message') {
+                const content = formatted.content?.trim();
+                // Skip empty assistant.message events (tool-call signals)
+                if (!content)
+                    return;
+                // Non-empty — check for NO_REPLY
+                if (content === 'NO_REPLY' || content === '`NO_REPLY`') {
+                    log.info(`Filtered NO_REPLY (quiet mode) on channel ${channelId.slice(0, 8)}...`);
+                    exitQuietMode(channelId);
+                    const sk = activeStreams.get(channelId);
+                    if (sk) {
+                        await streaming.deleteStream(sk);
+                        activeStreams.delete(channelId);
+                    }
+                    return;
+                }
+                // Real content — flush: create stream with this content, exit quiet
+                log.info(`Quiet mode flush on channel ${channelId.slice(0, 8)}... — real content received`);
+                const savedThreadRoot = channelThreadRoots.get(channelId);
+                exitQuietMode(channelId);
+                const newKey = await streaming.startStream(channelId, savedThreadRoot, content);
+                activeStreams.set(channelId, newKey);
+                return;
             }
+        }
+        // Suppress verbose/tool/status events during quiet — but let session.idle
+        // and session.error pass through so channel idle tracking still works
+        if (formatted.type === 'tool_start' || formatted.type === 'tool_complete') {
+            return;
+        }
+        if (formatted.type === 'status' && event.type !== 'session.idle') {
             return;
         }
+        // Errors: exit quiet and fall through to normal error handling (surfaces to user)
+        if (formatted.type === 'error') {
+            exitQuietMode(channelId);
+            // Fall through to normal error handling
+        }
     }
     if (formatted.verbose && !verbose)
         return;
@@ -1603,8 +1907,8 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
                 }
             }
             if (!streamKey) {
-                // Suppress stream auto-start during startup nudge — avoid visible "Working..." flash
-                if (nudgePending.has(channelId))
+                // Suppress stream auto-start during quiet mode — avoid visible "Working..." flash
+                if (isQuiet(channelId))
                     break;
                 // Auto-start stream — use actual content, never a "Working..." placeholder.
                 // This happens on subsequent turns after turn_end finalized the previous stream.
@@ -1656,7 +1960,7 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
                         `Will reset session if it continues.`);
                 }
             }
-            if (verbose && formatted.content && !nudgePending.has(channelId)) {
+            if (verbose && formatted.content && !isQuiet(channelId)) {
                 await appendActivityFeed(channelId, formatted.content, adapter);
             }
             break;
@@ -1665,7 +1969,7 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
             break;
         case 'error':
             markIdleImmediate(channelId);
-            nudgePending.delete(channelId);
+            exitQuietMode(channelId);
             channelThreadRoots.delete(channelId);
             if (streamKey) {
                 await streaming.cancelStream(streamKey, formatted.content);
@@ -1720,7 +2024,7 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
             // Finalize stream when the session goes idle (all turns complete).
             if (event.type === 'session.idle') {
                 markIdle(channelId);
-                nudgePending.delete(channelId);
+                exitQuietMode(channelId);
                 await finalizeActivityFeed(channelId, adapter);
                 initialStreamPosted.delete(channelId);
                 channelThreadRoots.delete(channelId);
@@ -1729,6 +2033,10 @@ async function handleSessionEvent(sessionId, channelId, event, sessionManager) {
                     await streaming.finalizeStream(streamKey);
                     activeStreams.delete(channelId);
                 }
+                // Revert yolo if it was temporarily enabled for plan implementation
+                if (sessionManager.revertYoloIfNeeded(channelId)) {
+                    log.info(`Reverted yolo state on idle for ${channelId.slice(0, 8)}...`);
+                }
                 // Clean up temp files from downloaded attachments
                 cleanupTempFiles(channelId);
             }
@@ -1804,11 +2112,16 @@ async function nudgeAdminSessions(sessionManager) {
                     resolved.adapter.sendMessage(channelId, '🔄 Bridge restarted.').catch(e => log.warn(`Failed to post restart notice on ${channelId.slice(0, 8)}...:`, e));
                 }
             }
-            nudgePending.add(channelId);
-            await sessionManager.sendMessage(channelId, NUDGE_PROMPT);
+            const clearQuiet = enterQuietMode(channelId);
+            try {
+                await sessionManager.sendMessage(channelId, NUDGE_PROMPT);
+            }
+            finally {
+                clearQuiet();
+            }
         }
         catch (err) {
-            nudgePending.delete(channelId);
+            exitQuietMode(channelId);
             log.warn(`Failed to nudge admin session on channel ${channelId.slice(0, 8)}...:`, err);
         }
     }