@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/input/commands/operator-actions-runtime.ts

@@ -93,14 +93,17 @@ function automationActionFromParts(scope: string, verb: string): {
   readonly targetField: 'jobId' | 'runId' | 'scheduleId';
 } | null {
   if ((scope === 'job' || scope === 'jobs') && verb === 'run') return { action: 'automation.jobs.run', targetField: 'jobId' };
-  if ((scope === 'job' || scope === 'jobs') && verb === 'pause') return { action: 'automation.jobs.pause', targetField: 'jobId' };
-  if ((scope === 'job' || scope === 'jobs') && verb === 'resume') return { action: 'automation.jobs.resume', targetField: 'jobId' };
+  // W6-C3: automation.jobs.pause/resume retired (redundant with
+  // disable/enable) — the user-facing "pause"/"resume" verb is unchanged,
+  // it now maps onto the canonical disable/enable wire actions.
+  if ((scope === 'job' || scope === 'jobs') && verb === 'pause') return { action: 'automation.jobs.disable', targetField: 'jobId' };
+  if ((scope === 'job' || scope === 'jobs') && verb === 'resume') return { action: 'automation.jobs.enable', targetField: 'jobId' };
   if ((scope === 'run' || scope === 'runs') && verb === 'cancel') return { action: 'automation.runs.cancel', targetField: 'runId' };
   if ((scope === 'run' || scope === 'runs') && verb === 'retry') return { action: 'automation.runs.retry', targetField: 'runId' };
-  if ((scope === 'schedule' || scope === 'schedules') && verb === 'run') return { action: 'schedules.run', targetField: 'scheduleId' };
-  if ((scope === 'schedule' || scope === 'schedules') && verb === 'enable') return { action: 'schedules.enable', targetField: 'scheduleId' };
-  if ((scope === 'schedule' || scope === 'schedules') && verb === 'disable') return { action: 'schedules.disable', targetField: 'scheduleId' };
-  if ((scope === 'schedule' || scope === 'schedules') && (verb === 'delete' || verb === 'remove')) return { action: 'schedules.delete', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && verb === 'run') return { action: 'automation.schedules.run', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && verb === 'enable') return { action: 'automation.schedules.enable', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && verb === 'disable') return { action: 'automation.schedules.disable', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && (verb === 'delete' || verb === 'remove')) return { action: 'automation.schedules.delete', targetField: 'scheduleId' };
   return null;
 }
 

package/src/input/commands/personas-runtime.ts

@@ -41,7 +41,7 @@ function summarizePersona(persona: AgentPersonaRecord, activePersonaId: string |
 function renderList(title: string, registry: AgentPersonaRegistry, personas: readonly AgentPersonaRecord[]): string {
   const snapshot = registry.snapshot();
   if (personas.length === 0) {
-    return `${title}\n  No local Agent personas yet.\n  No Agent-local personas yet. Create one with /personas create --name <name> --description <summary> --body <instructions>.`;
+    return `${title}\n  No local Agent personas yet. Create one with /personas create --name <name> --description <summary> --body <instructions>.`;
   }
   return [
     `${title} (${personas.length})`,

package/src/input/commands/schedule-runtime.ts

@@ -216,12 +216,12 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         const action = sub === 'run'
-          ? 'schedules.run'
+          ? 'automation.schedules.run'
           : sub === 'enable'
-            ? 'schedules.enable'
+            ? 'automation.schedules.enable'
             : sub === 'disable'
-              ? 'schedules.disable'
-              : 'schedules.delete';
+              ? 'automation.schedules.disable'
+              : 'automation.schedules.delete';
         await executeConfirmedOperatorAction(ctx, action, 'scheduleId', scheduleId, args.slice(2), `/schedule ${sub} <schedule-id> --yes`);
         return;
       }

package/src/input/commands/session-content.ts

@@ -6,6 +6,7 @@ import type { SelectionItem } from '../selection-modal.ts';
 import type { SessionMeta } from '@pellux/goodvibes-sdk/platform/sessions';
 import { exportToMarkdown, extractText } from '@pellux/goodvibes-sdk/platform/export';
 import { requireSessionManager, requireShellPaths } from './runtime-services.ts';
+import { sessionCommand } from './session.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 import { readConversationMessageSnapshots } from '../../core/conversation-message-snapshot.ts';
@@ -250,8 +251,19 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
   registry.register({
     name: 'sessions',
     description: 'List saved sessions',
-    hidden: true,
+    usage: '[resume <id|name>]',
+    argsHint: '[resume <id|name>]',
     async handler(_args, ctx) {
+      // Matches the TUI's /sessions (W6-C3, worst-class collision #5): this
+      // was `hidden: true` here — invisible in help/autocomplete — even
+      // though it is a fully working command identical in behavior to the
+      // TUI's visible one. Also forward args to /session (the TUI's fix for
+      // the `/sessions resume <id>` muscle-memory case), instead of silently
+      // listing and dropping the subcommand+id on the floor.
+      if (_args.length > 0) {
+        await sessionCommand.handler(_args, ctx);
+        return;
+      }
       const sessionManager = requireSessionManager(ctx);
       const sessions = sessionManager.list();
       if (ctx.openSelection) {

package/src/input/commands/session-workflow.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from 'node:crypto';
 
-import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { CommandContext } from '../command-registry.ts';
 import { type SessionMeta } from '@pellux/goodvibes-sdk/platform/sessions';
 import type { TranscriptEventKind } from '@pellux/goodvibes-sdk/platform/core';
 import type { SessionReturnContextSummary } from '@/runtime/index.ts';
@@ -479,22 +479,17 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
   return false;
 }
 
-export function registerSessionWorkflowCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'session',
-    aliases: ['sess'],
-    description: 'Manage sessions, resume posture, and transcript structure',
-    usage: '[list | rename <name> | resume <id|name> | fork | save | info <id> | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id> --yes]',
-    argsHint: '<list|rename|resume|fork|save|info|events|groups|hotspots|export|search|delete>',
-    async handler(args, ctx) {
-      const handled = await handleSessionWorkflowCommand(args, ctx);
-      if (!handled) {
-        ctx.print([
-          'Unknown session subcommand',
-          `  subcommand ${args[0] ?? ''}`,
-          'Usage: /session [list | rename <name> | resume <id> | fork [name] | save [name] | info [id] | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id> --yes]',
-        ].join('\n'));
-      }
-    },
-  });
-}
+// NOTE (W6-C3, Wave 6 core-verb pass): this file used to also export
+// registerSessionWorkflowCommands(), a second top-level `/session` (alias
+// `sess`) registration with its own usage text. It was NEVER called from
+// startup — commands.ts only registers `sessionCommand` from ./session.ts —
+// so it was dead code (would throw a CommandRegistry collision error if
+// anyone ever did call it, since sessionCommand already owns the name). It
+// has been deleted; there is no functional change, because sessionCommand's
+// own default-branch fallback already calls handleSessionWorkflowCommand
+// above for every subcommand this dead registrar advertised, including
+// events/groups/hotspots — see ./session.ts's usage text, which now documents
+// them too. See docs/decisions/2026-07-06-core-verb-spec.md (agent /session
+// orphan, worst-class collision #4) and
+// src/test/input/session-single-registration.test.ts for the regression
+// guard.

package/src/input/commands/session.ts

@@ -152,7 +152,7 @@ export const sessionCommand: SlashCommand = {
   aliases: ['sess'],
   description: 'Session continuity and read-only cross-session graph inspection.',
   usage: '<subcommand> [args]',
-  argsHint: 'list|resume|save|graph',
+  argsHint: 'list|resume|save|events|groups|hotspots|graph',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
@@ -183,6 +183,8 @@ export const sessionCommand: SlashCommand = {
             'Usage: /session <subcommand>',
             '  list | rename <name> | resume <id|name> | fork [name] | save [name] | info [id] | export <id> [format] | search <query> | delete <id> --yes',
             '                                 — Session continuity, export, resume, and pruning',
+            '  events [kind] | groups [kind] | hotspots',
+            '                                 — Transcript structure: event log, grouped view, hotspot summary',
             '  graph [--session <sid>] [--format text|json]',
             '                                 — Display the cross-session task dependency graph',
             '  link-task | handoff | cancel',

package/src/input/commands/shell-core.ts

@@ -99,9 +99,18 @@ function commandDetail(command: SlashCommand): string {
   return parts.join(' | ');
 }
 
-function listRegisteredCommandItems(registry: CommandRegistry): SelectionItem[] {
+/**
+ * List registered commands as selection items.
+ *
+ * Hidden commands (`SlashCommand.hidden`) still run when typed and stay
+ * discoverable via `/commands`, which lists everything labeled "(hidden)".
+ * `/help` (both the interactive picker and the plain-text fallback) filters
+ * them out per the doc contract on `SlashCommand.hidden`.
+ */
+function listRegisteredCommandItems(registry: CommandRegistry, options: { includeHidden: boolean }): SelectionItem[] {
   return registry.list()
     .slice()
+    .filter((command) => options.includeHidden || !command.hidden)
     .sort((a, b) => a.name.localeCompare(b.name))
     .map((command) => ({
       id: `/${command.name}`,
@@ -114,7 +123,7 @@ function listRegisteredCommandItems(registry: CommandRegistry): SelectionItem[]
 }
 
 function registeredCommandListText(registry: CommandRegistry): string {
-  const commands = listRegisteredCommandItems(registry);
+  const commands = listRegisteredCommandItems(registry, { includeHidden: false });
   return [
     'Open the Agent workspace first, then press / inside it to search every product action.',
     '',
@@ -123,8 +132,13 @@ function registeredCommandListText(registry: CommandRegistry): string {
   ].join('\n');
 }
 
-function openRegisteredCommandSelection(registry: CommandRegistry, ctx: CommandContext): void {
-  ctx.openSelection?.('Help  -  Commands', listRegisteredCommandItems(registry), { allowSearch: true }, (result) => {
+function openRegisteredCommandSelection(
+  registry: CommandRegistry,
+  ctx: CommandContext,
+  options: { includeHidden: boolean },
+): void {
+  const items = listRegisteredCommandItems(registry, options);
+  ctx.openSelection?.('Help  -  Commands', items, { allowSearch: true }, (result) => {
     if (!result) return;
     const command = result.item.id;
     if (command.startsWith('/')) {
@@ -184,7 +198,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     description: 'Browse all commands in a scrollable list',
     handler(_args, ctx) {
       if (ctx.openSelection) {
-        openRegisteredCommandSelection(registry, ctx);
+        openRegisteredCommandSelection(registry, ctx, { includeHidden: true });
         return;
       }
       if (ctx.openHelpOverlay) {
@@ -256,7 +270,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     argsHint: '[command]',
     handler(_args, ctx) {
       if (ctx.openSelection) {
-        openRegisteredCommandSelection(registry, ctx);
+        openRegisteredCommandSelection(registry, ctx, { includeHidden: false });
         return;
       }
       ctx.print(registeredCommandListText(registry));

package/src/input/commands.ts

@@ -5,7 +5,6 @@ import { recallCommand } from './commands/memory.ts';
 import { knowledgeCommand } from './commands/knowledge.ts';
 import { registerShellCoreCommands } from './commands/shell-core.ts';
 import { registerConfigCommand } from './commands/config.ts';
-import { registerSessionWorkflowCommands } from './commands/session-workflow.ts';
 import { registerScheduleRuntimeCommands } from './commands/schedule-runtime.ts';
 import { registerOperatorRuntimeCommands } from './commands/operator-runtime.ts';
 import { registerNotifyRuntimeCommands } from './commands/notify-runtime.ts';
@@ -20,6 +19,7 @@ import { registerLocalRuntimeCommands } from './commands/local-runtime.ts';
 import { registerExperienceRuntimeCommands } from './commands/experience-runtime.ts';
 import { registerTasksRuntimeCommands } from './commands/tasks-runtime.ts';
 import { registerLocalProviderRuntimeCommands } from './commands/local-provider-runtime.ts';
+import { registerNetworkScanRuntimeCommands } from './commands/network-scan-runtime.ts';
 import { registerHealthRuntimeCommands } from './commands/health-runtime.ts';
 import { registerProviderAccountsRuntimeCommands } from './commands/provider-accounts-runtime.ts';
 import { registerConversationRuntimeCommands } from './commands/conversation-runtime.ts';
@@ -86,6 +86,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerExperienceRuntimeCommands(registry);
   registerTasksRuntimeCommands(registry);
   registerLocalProviderRuntimeCommands(registry);
+  registerNetworkScanRuntimeCommands(registry);
   registerHealthRuntimeCommands(registry);
   registerProviderAccountsRuntimeCommands(registry);
   registerConversationRuntimeCommands(registry);
@@ -93,7 +94,6 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerOnboardingRuntimeCommands(registry);
   registerTtsRuntimeCommands(registry);
   registerLocalRuntimeCommands(registry);
-  registerSessionWorkflowCommands(registry);
   registerScheduleRuntimeCommands(registry);
   registerSessionContentCommands(registry);
   registerAgentMemoryCommand(registry);

package/src/input/delete-key-policy.ts

@@ -0,0 +1,46 @@
+// ---------------------------------------------------------------------------
+// Delete-key policy — single source of truth for text-editing key semantics
+//
+// In text-editing contexts:
+//   'backspace'  → delete one character backward (the character before cursor /
+//                  the last character in an end-anchored buffer)
+//   'delete'     → forward-delete (the character after cursor) when a moveable
+//                  cursor exists; a no-op in cursorless/end-anchored contexts,
+//                  EXCEPT where it opens a confirmation-gated clear action
+//                  (see planning panel: Delete opens the ConfirmState gate that
+//                  lets the user clear their entire draft answer).
+//
+// Consequences for each surface:
+//   Panel search filters (end-anchored, no cursor)
+//     'backspace' → remove last char   ✓
+//     'delete'    → no-op              ✓ (no cursor; nothing is "forward")
+//
+//   Selection modal filters (end-anchored, no cursor)
+//     'backspace' → remove last char   ✓
+//     'delete'    → no-op              ✓
+//
+//   Planning panel draft answer (end-anchored, no cursor)
+//     'backspace' → remove last char   ✓
+//     'delete'    → open ConfirmState gate (y/Enter confirms clear; n/Esc cancels)
+//                   The draft is NOT wiped until the user confirms.
+//
+// NEVER assign bulk-destructive actions (clear / wipe) to the Delete key
+// without an explicit confirmation gate.
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when `key` should perform a backward-delete (remove the
+ * character before the cursor / at end of an end-anchored buffer).
+ */
+export function isTextBackspace(key: string): boolean {
+  return key === 'backspace';
+}
+
+/**
+ * Returns true when `key` should perform a forward-delete (remove the
+ * character after the cursor). Only meaningful when a moveable cursor
+ * exists; callers should treat this as a no-op when there is no cursor.
+ */
+export function isTextForwardDelete(key: string): boolean {
+  return key === 'delete';
+}

package/src/input/feed-context-factory.ts

@@ -35,6 +35,8 @@ import type { ProfilePickerModal } from './profile-picker-modal.ts';
 import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
+import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
+import type { FocusTracker } from '../core/focus-tracker.ts';
 
 /**
  * Initial mutable scalar values for InputFeedContext.
@@ -93,6 +95,10 @@ export interface FeedContextStableRefs {
   selection: SelectionManager;
   pasteRegistry: Map<string, string>;
   imageRegistry: Map<string, { data: string; mediaType: string }>;
+  /** W4-R3 — ported from goodvibes-tui's DEBT-5 item 5; mutated in place, never reallocated. */
+  burstGuard: PanelBurstGuardState;
+  /** W4-R3 — OS-level terminal focus tracker, ported from goodvibes-tui's W2.3. */
+  focusTracker: FocusTracker;
   projectRoot: string;
   selectionModal: SelectionModal;
   bookmarkModal: BookmarkModal;
@@ -176,6 +182,10 @@ export function buildInitialFeedContext(
     ...mutable,
     // --- requestRender: placeholder, swapped per-feed to buffered version ---
     requestRender: noop,
+    // W4-R3: wiring-layer-only bookkeeping for the paste-flood guard's honest
+    // resolution notice (not part of the ported panel-paste-flood-guard.ts
+    // module itself; see handler-feed.ts's feedInputTokens).
+    burstSuppressedCount: 0,
     // --- stable refs ---
     ...stable,
     // --- closures ---

package/src/input/handler-feed.ts

@@ -37,6 +37,8 @@ import { handleGlobalShortcutToken } from './handler-shortcuts.ts';
 import { SelectionManager } from './selection.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
+import { trackPanelPasteFloodGuard, type PanelBurstGuardState } from './panel-paste-flood-guard.ts';
+import type { FocusTracker } from '../core/focus-tracker.ts';
 
 /**
  * InputFeedContext — The single long-lived context object passed to feedInputTokens
@@ -62,6 +64,16 @@ import type { ModelPickerTarget } from './model-picker.ts';
  *   - `inputHistory`, `conversationManager` — late-wired service handles; synced at
  *     feed() entry only since no in-feed action rewires them
  *   - `pasteRegistry`, `imageRegistry` — owned Maps, never replaced
+ *   - `burstGuard` (W4-R3, ported from goodvibes-tui's DEBT-5 item 5) — the
+ *     unbracketed-paste-flood guard's sliding-window state, mutated in place
+ *     across tokens by trackPanelPasteFloodGuard (see panel-paste-flood-guard.ts).
+ *     Never reallocated. `burstSuppressedCount` is this wiring layer's own
+ *     bookkeeping (not part of the ported module) for the honest resolution
+ *     notice — see feedInputTokens below.
+ *   - `focusTracker` (W4-R3, ported from goodvibes-tui's W2.3) — tracks OS-level
+ *     terminal focus from `\x1b[I`/`\x1b[O` tokens (DECSET ?1004h, enabled in
+ *     main.ts). Shared instance from RuntimeServices, threaded via
+ *     uiServices.platform.focusTracker (mirrors the TUI's own wiring).
  *   - `selectionModal`, `bookmarkModal`, `settingsModal`, `sessionPickerModal`,
  *     `profilePickerModal` — modal objects constructed once in InputHandler constructor
  *   - `filePicker`, `modelPicker`, `processModal`, `liveTailModal`,
@@ -93,6 +105,12 @@ export interface InputFeedContext {
   contentWidth: number;
   readonly pasteRegistry: Map<string, string>;
   readonly imageRegistry: Map<string, { data: string; mediaType: string }>;
+  /** W4-R3 (ported from goodvibes-tui DEBT-5 item 5) — mutated in place, never reallocated. */
+  readonly burstGuard: PanelBurstGuardState;
+  /** W4-R3 wiring-layer bookkeeping (not part of the ported module) for the honest suppressed-count notice. */
+  burstSuppressedCount: number;
+  /** W4-R3 (ported from goodvibes-tui W2.3) — OS-level terminal focus, fed from 'focus' tokens below. */
+  readonly focusTracker: FocusTracker;
   readonly projectRoot: string;
   readonly selection: SelectionManager;
   readonly selectionModal: SelectionModal;
@@ -158,8 +176,20 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
   const scrollTop = context.getScrollTop();
   const lineCount = history.getLineCount();
   const keybindings = context.keybindingsManager;
+  // W4-R3: one `now` per feed() call (not per token) — a genuine unbracketed-paste
+  // flood delivers many tokens in one drain, and they should all measure as
+  // arriving "at once" (mirrors goodvibes-tui's handler-feed.ts DEBT-5 item 5 doc).
+  const now = Date.now();
 
   for (const token of tokens) {
+    // W4-R3 (ported from goodvibes-tui W2.3): focus-reporting tokens (CSI ?1004h)
+    // never reach the composer or any modal route — consumed here, first,
+    // unconditionally. No render needed.
+    if (token.type === 'focus') {
+      context.focusTracker.setFocused(token.action === 'in');
+      continue;
+    }
+
     if (token.type === 'key' && context.keybindingsManager.matches('clear-cancel', token)) {
       context.handleCtrlC();
       continue;
@@ -264,6 +294,63 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       }
     }
 
+    // W4-R3 (ported from goodvibes-tui's panel-paste-flood-guard.ts, DEBT-5 item
+    // 5): guards command-mode's key-driven dispatch (handleCommandModeToken,
+    // below) from an unbracketed-paste-replay or control-character-injection
+    // burst.
+    //
+    // SCOPE — 'key' tokens, and only while commandMode is active: the TUI's
+    // own guard exempts any "capturing" text surface entirely (its own test
+    // asserts a capturing panel "receives the full burst untouched by the
+    // flood guard" — see panel-focus-route.test.ts) and never touches its own
+    // non-panel-focused composer's key handling at all. This agent's plain
+    // composer (commandMode false) is exactly that kind of capturing/untouched
+    // surface — handlePromptTextToken absorbs pasted/typed text of any length
+    // by plain insertion, and handlePromptKeyToken's arrow/backspace/enter
+    // handling is the same shape as the TUI's own unguarded composer key
+    // route. Guarding those would falsely trip on ordinary fast/bulk delivery
+    // (a single feed() call carrying many characters/keys shares one `now`,
+    // indistinguishable from a real flood under this millisecond-resolution
+    // model — confirmed by a regression in this repo's own
+    // command-modal-handoff.test.ts when an earlier version of this guard
+    // covered all 'key'/'text' tokens unconditionally) and would add new,
+    // product-inconsistent friction (e.g. held-arrow-key auto-repeat) to the
+    // agent's default interaction mode that the TUI's own users don't have.
+    //
+    // commandMode's key dispatch is the genuine analog of a TUI panel's
+    // per-character hotkey dispatch — matching the R1 matrix's own adaptation
+    // note, "the burst instead becomes command/keybinding dispatch": once
+    // commandMode is armed (state.prompt starts with '/'), Enter EXECUTES a
+    // slash command (handler-command-route.ts), Tab completes, up/down
+    // navigate — real state-changing single-key actions. An unbracketed
+    // paste whose content happens to start with '/' and contains a bare '\r'
+    // partway through (not '\n' — the tokenizer maps '\n' to shift+enter/
+    // newline-insert, code10; only '\r'/code13 is a genuine 'enter' key, see
+    // platform/core/tokenizer.ts) would otherwise execute a slash command
+    // early with truncated/wrong arguments. A human never sends 9 key-tokens
+    // within 120ms.
+    //
+    // UX-FIRST / HONEST DEGRADED STATE: never silent — a one-shot notice fires
+    // the moment the guard trips, and a second notice reports how many
+    // keystrokes it suppressed once the burst quiets down.
+    if (token.type === 'key' && context.commandMode) {
+      const wasSuspended = context.burstGuard.suspended;
+      const guard = trackPanelPasteFloodGuard(context.burstGuard, now);
+      if (!guard.dispatch) {
+        context.burstSuppressedCount++;
+        if (guard.showHintNow) {
+          context.commandContext?.print('[paste] unbracketed paste flood detected — suppressing extra keystrokes until it settles');
+          context.requestRender();
+        }
+        continue;
+      }
+      if (wasSuspended) {
+        context.commandContext?.print(`[paste] flood cleared — suppressed ${context.burstSuppressedCount} keystroke(s)`);
+        context.burstSuppressedCount = 0;
+        context.requestRender();
+      }
+    }
+
     const indicatorRoute = handleIndicatorFocusToken({
       indicatorFocused: context.indicatorFocused,
       modalOpened: context.modalOpened,

package/src/input/handler-modal-routes.ts

@@ -2,6 +2,7 @@ import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { SelectionResult, SelectionAction } from './selection-modal.ts';
 import type { CommandContext } from './command-registry.ts';
 import { openTtsProviderPicker, openTtsVoicePicker } from './tts-settings-actions.ts';
+import { isTextBackspace } from './delete-key-policy.ts';
 
 type SelectionRouteState = {
   selectionModal: {
@@ -136,7 +137,11 @@ export function handleSelectionModalToken(state: SelectionRouteState, token: Inp
           getAdjustmentStep(selected, token.shift),
         );
       }
-    } else if (token.logicalName === 'backspace') {
+    } else if (isTextBackspace(token.logicalName ?? '')) {
+      // delete-key-policy (R3 port, ported from goodvibes-tui): this end-anchored
+      // search filter has no cursor, so 'delete' (isTextForwardDelete) is correctly
+      // a no-op here — it simply falls through this else-if chain untouched, same
+      // as the TUI's identical SelectionModal search-filter route.
       if (state.selectionModal.allowSearch && state.selectionModal.searchFocused && state.selectionModal.query.length > 0) {
         state.selectionModal.setQuery(state.selectionModal.query.slice(0, -1));
       }

package/src/input/handler.ts

@@ -67,6 +67,7 @@ import { feedInputTokens } from './handler-feed.ts';
 import { buildInitialFeedContext, syncFeedContextMutableFields } from './feed-context-factory.ts';
 import type { UiRuntimeServices } from '../runtime/ui-services.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
+import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 
 type SelectionModalCallback = (result: SelectionResult | null) => void;
 
@@ -93,6 +94,8 @@ export class InputHandler {
   public pasteRegistry = new Map<string, string>();
   public nextPasteId = 1;
   public lastCtrlCTime = 0;
+  /** W4-R3 (ported from goodvibes-tui DEBT-5 item 5) — unbracketed-paste-flood guard state, mutated in place. */
+  public burstGuard: PanelBurstGuardState = { timestamps: [], suspended: false, hintShown: false };
   /** Long-lived feed context — reused across every feed() call to avoid per-keystroke allocation. */
   public feedContext!: import('./handler-feed.ts').InputFeedContext;
   public commandRegistry: CommandRegistry | null = null;
@@ -207,6 +210,8 @@ export class InputHandler {
         selection: this.selection,
         pasteRegistry: this.pasteRegistry,
         imageRegistry: this.imageRegistry,
+        burstGuard: this.burstGuard,
+        focusTracker: this.uiServices.platform.focusTracker,
         projectRoot: this.uiServices.environment.shellPaths.workingDirectory,
         selectionModal: this.selectionModal,
         bookmarkModal: this.bookmarkModal,

package/src/input/panel-paste-flood-guard.ts

@@ -0,0 +1,94 @@
+// ---------------------------------------------------------------------------
+// panel-paste-flood-guard.ts — ported from goodvibes-tui (commit 90eb3a26,
+// DEBT-5 item 5), W4-R3.
+//
+// A terminal WITHOUT bracketed paste delivers a pasted block as a burst of
+// discrete 1-char 'text' tokens (isPasteToken stays false for every one of
+// them, since that flag only fires for a single token whose value.length > 1).
+//
+// AGENT ADAPTATION (this repo has no `src/panels/` — see the W4-R1 parity
+// matrix's R3 row): the TUI wires this guard inside handlePanelFocusToken,
+// where it protects a focused PANEL from having each replayed character
+// dispatched as a real hotkey (K arms kill, etc). This agent has no panel
+// focus concept at all — every token that isn't consumed by a modal route or
+// a global shortcut lands directly in the composer/command dispatch chain
+// (handleIndicatorFocusToken -> handlePromptTextToken -> handleCommandModeToken
+// -> handlePromptKeyToken, see handler-feed.ts). The matrix's own adaptation
+// note ("the burst instead becomes command/keybinding dispatch — the guard
+// wires above the composer/command dispatch") is implemented by gating that
+// same chain in feedInputTokens: see handler-feed.ts's per-token loop, which
+// calls trackPanelPasteFloodGuard for every non-paste 'text' token BEFORE
+// those routes run, using a persistent PanelBurstGuardState carried on
+// InputFeedContext (context.burstGuard — mirrors how pasteRegistry is
+// threaded as a stable, never-reallocated field; see feed-context-factory.ts).
+//
+// This module's own logic is UI-framework-agnostic and is kept byte-identical
+// to the TUI's (same constants, same sliding-window algorithm) — only its
+// CALLERS differ between the two products.
+//
+// This is a RATE guard: more than PANEL_PASTE_FLOOD_THRESHOLD qualifying
+// tokens within the trailing PANEL_PASTE_FLOOD_WINDOW_MS, evaluated with a
+// real sliding window (old timestamps age out of `timestamps` every call). It
+// is deliberately NOT a per-feed char-SUM burst heuristic: that shape summed
+// one feed()'s character count with no timing signal at all, so two ordinary
+// keystrokes landing in a single feed() (a real, common case) could be
+// misread as a burst. This guard:
+//   - is keyed on WALL-CLOCK TIMING, not a per-feed token count, so it
+//     doesn't care how many tokens land in one feed() call, only how fast
+//     they arrive relative to each other;
+//   - is sticky once tripped (only a quiet gap — no qualifying token for a
+//     full window — clears it) so it doesn't flap dispatch on/off as the
+//     count oscillates near the threshold mid-flood.
+//
+// ~8 keys/120ms is far beyond sustained human typing (a fast typist peaks
+// well under that inter-key rate over any real span) but is exactly the
+// shape an unbracketed paste replay takes.
+// ---------------------------------------------------------------------------
+
+export const PANEL_PASTE_FLOOD_WINDOW_MS = 120;
+export const PANEL_PASTE_FLOOD_THRESHOLD = 8;
+
+/**
+ * Guard state — a single persistent instance lives on the caller's
+ * long-lived context (this agent's handler-feed.ts InputFeedContext, mirroring
+ * how that object already owns `nextPasteId`/`mouseDownRow`/etc.) and is
+ * MUTATED IN PLACE by trackPanelPasteFloodGuard below, never replaced — so
+ * callers never need to thread a return value back into their own state.
+ */
+export interface PanelBurstGuardState {
+  timestamps: readonly number[];
+  suspended: boolean;
+  hintShown: boolean;
+}
+
+export interface PanelBurstGuardResult {
+  /** False while suspended — the caller must drop this token, not dispatch it. */
+  readonly dispatch: boolean;
+  /** True exactly once per burst: the call that just tripped suspension. */
+  readonly showHintNow: boolean;
+}
+
+/** Advance `guard` (mutated in place) by one qualifying token at time `now` (ms). */
+export function trackPanelPasteFloodGuard(guard: PanelBurstGuardState, now: number): PanelBurstGuardResult {
+  const lastAt = guard.timestamps.length > 0 ? guard.timestamps[guard.timestamps.length - 1]! : -Infinity;
+  const isQuietGap = now - lastAt > PANEL_PASTE_FLOOD_WINDOW_MS;
+  if (isQuietGap && guard.suspended) {
+    // A silence at least as long as the window means whatever burst was
+    // happening has ended — un-suspend so a LATER burst gets its own fresh
+    // count and its own one-shot hint.
+    guard.suspended = false;
+    guard.hintShown = false;
+  }
+  guard.timestamps = isQuietGap
+    ? [now]
+    : [...guard.timestamps.filter((t) => t > now - PANEL_PASTE_FLOOD_WINDOW_MS), now];
+  if (guard.timestamps.length > PANEL_PASTE_FLOOD_THRESHOLD) {
+    guard.suspended = true;
+  }
+  let showHintNow = false;
+  if (guard.suspended && !guard.hintShown) {
+    guard.hintShown = true;
+    showHintNow = true;
+  }
+  return { dispatch: !guard.suspended, showHintNow };
+}

package/src/input/settings-modal-types.ts

@@ -39,6 +39,7 @@ export type SettingsCategory =
   | 'watchers'
   | 'network'
   | 'orchestration'
+  | 'planner'
   | 'runtime'
   | 'sandbox'
   | 'batch'
@@ -48,7 +49,8 @@ export type SettingsCategory =
   | 'cache'
   | 'mcp'
   | 'flags'
-  | 'release';
+  | 'release'
+  | 'daemon';
 
 export type SettingsFocusPane = 'categories' | 'settings';
 
@@ -60,8 +62,8 @@ export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
   { label: 'Models and Providers', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts'] },
   { label: 'Agent-local state', categories: ['storage', 'cache', 'telemetry'] },
   { label: 'Channels and Tools', categories: ['surfaces', 'mcp', 'automation'] },
-  { label: 'Daemon Runtime', categories: ['service', 'controlPlane', 'httpListener', 'web', 'watchers', 'network'] },
-  { label: 'Advanced Runtime', categories: ['orchestration', 'runtime', 'sandbox', 'batch', 'cloudflare', 'wrfc'] },
+  { label: 'Daemon Runtime', categories: ['daemon', 'service', 'controlPlane', 'httpListener', 'web', 'watchers', 'network'] },
+  { label: 'Advanced Runtime', categories: ['orchestration', 'planner', 'runtime', 'sandbox', 'batch', 'cloudflare', 'wrfc'] },
   { label: 'Advanced', categories: ['flags', 'release'] },
 ];