erosolar-cli 1.7.393 → 1.7.395

package/dist/shell/terminalInput.js

@@ -118,14 +118,17 @@ export class TerminalInput extends EventEmitter {
     editMode = 'display-edits';
     verificationEnabled = true;
     autoContinueEnabled = false;
-    verificationHotkey = 'alt+v';
-    autoContinueHotkey = 'alt+c';
-    thinkingHotkey = '/thinking';
+    verificationHotkey = 'ctrl+shift+v';
+    autoContinueHotkey = 'ctrl+shift+c';
+    thinkingHotkey = 'ctrl+shift+t';
+    alphaZeroModeEnabled = false;
+    alphaZeroHotkey = 'ctrl+shift+a';
+    alphaZeroLabel = null;
     modelLabel = null;
     providerLabel = null;
     // Streaming render throttle
     lastStreamingRender = 0;
-    streamingRenderInterval = 250; // ms between renders during streaming
+    streamingRenderInterval = 150; // ms between renders during streaming
     streamingRenderTimer = null;
     // Command autocomplete state
     commandSuggestions = [];
@@ -137,6 +140,8 @@ export class TerminalInput extends EventEmitter {
     lastChatBoxStartRow = null;
     lastChatBoxHeight = 0;
     displayInterceptorDispose = null;
+    recentActions = [];
+    maxRecentActions = 5;
     constructor(writeStream = process.stdout, config = {}) {
         super();
         this.out = writeStream;
@@ -293,10 +298,20 @@ export class TerminalInput extends EventEmitter {
         const normalizedName = key?.name ?? this.getArrowKeyName(key?.sequence ?? str);
         const effectiveKey = normalizedName ? { ...key, name: normalizedName } : key;
         const safeStr = this.isArrowEscapeFragment(str) ? undefined : str;
+        // Some terminals emit raw DEL/backspace bytes without a parsed key name.
+        // Treat these as backspace to avoid inserting the control character.
+        const isRawBackspace = !effectiveKey?.name && safeStr && (safeStr === '\b' || safeStr === '\x7f');
+        if (isRawBackspace) {
+            this.deleteBackward();
+            return;
+        }
+        let handled = false;
         // Handle control keys
         if (effectiveKey?.ctrl) {
-            this.handleCtrlKey(effectiveKey);
-            return;
+            handled = this.handleCtrlKey(effectiveKey);
+            if (handled) {
+                return;
+            }
         }
         // Handle meta/alt keys
         if (effectiveKey?.meta) {
@@ -458,7 +473,8 @@ export class TerminalInput extends EventEmitter {
     /**
      * Handle selecting a suggestion (Enter key or click)
      */
-    selectSuggestion() {
+    selectSuggestion(options = {}) {
+        const { submit = false } = options;
         if (!this.showingSuggestions)
             return false;
         const filtered = this.getFilteredCommands();
@@ -468,10 +484,14 @@ export class TerminalInput extends EventEmitter {
         if (!selected)
             return false;
         // Replace buffer with selected command
-        this.buffer = selected.command + ' ';
+        const nextBuffer = submit ? selected.command : `${selected.command} `;
+        this.buffer = nextBuffer;
         this.cursor = this.buffer.length;
         this.showingSuggestions = false;
         this.scheduleRender();
+        if (submit) {
+            this.submit();
+        }
         return true;
     }
     /**
@@ -555,7 +575,7 @@ export class TerminalInput extends EventEmitter {
             visibleCount: Math.min(maxDisplay, Math.max(0, filtered.length - startIdx))
         };
         // Header with navigation hint - keep it short
-        lines.push(theme.ui.muted(`Commands (↑↓ Tab Enter)`));
+        lines.push(theme.ui.muted(`Commands (↑↓ Enter to run · Tab to fill)`));
         // Render visible suggestions
         for (let i = 0; i < maxDisplay; i++) {
             const idx = startIdx + i;
@@ -677,13 +697,19 @@ export class TerminalInput extends EventEmitter {
         const nextVerifyHotkey = options.verificationHotkey ?? this.verificationHotkey;
         const nextAutoHotkey = options.autoContinueHotkey ?? this.autoContinueHotkey;
         const nextThinkingHotkey = options.thinkingHotkey ?? this.thinkingHotkey;
+        const nextAlphaHotkey = options.alphaZeroHotkey ?? this.alphaZeroHotkey;
         const nextThinkingLabel = options.thinkingModeLabel === undefined ? this.thinkingModeLabel : (options.thinkingModeLabel || null);
+        const nextAlphaZeroEnabled = options.alphaZeroEnabled === undefined ? this.alphaZeroModeEnabled : !!options.alphaZeroEnabled;
+        const nextAlphaZeroLabel = options.alphaZeroLabel === undefined ? this.alphaZeroLabel : (options.alphaZeroLabel || null);
         if (this.verificationEnabled === nextVerification &&
             this.autoContinueEnabled === nextAutoContinue &&
             this.verificationHotkey === nextVerifyHotkey &&
             this.autoContinueHotkey === nextAutoHotkey &&
             this.thinkingHotkey === nextThinkingHotkey &&
-            this.thinkingModeLabel === nextThinkingLabel) {
+            this.thinkingModeLabel === nextThinkingLabel &&
+            this.alphaZeroModeEnabled === nextAlphaZeroEnabled &&
+            this.alphaZeroHotkey === nextAlphaHotkey &&
+            this.alphaZeroLabel === nextAlphaZeroLabel) {
             return;
         }
         this.verificationEnabled = nextVerification;
@@ -692,6 +718,9 @@ export class TerminalInput extends EventEmitter {
         this.autoContinueHotkey = nextAutoHotkey;
         this.thinkingHotkey = nextThinkingHotkey;
         this.thinkingModeLabel = nextThinkingLabel;
+        this.alphaZeroModeEnabled = nextAlphaZeroEnabled;
+        this.alphaZeroHotkey = nextAlphaHotkey;
+        this.alphaZeroLabel = nextAlphaZeroLabel;
         this.scheduleRender();
     }
     /**
@@ -729,8 +758,19 @@ export class TerminalInput extends EventEmitter {
         if (this.isRendering)
             return;
         const streamingActive = this.mode === 'streaming' || isStreamingMode();
-        // During streaming, throttle re-renders
-        if (streamingActive && this.lastStreamingRender > 0) {
+        if (this.scrollRegionActive && streamingActive) {
+            this.renderStreamingFrame();
+            return;
+        }
+        const bufferChanged = this.buffer !== this.lastRenderContent || this.cursor !== this.lastRenderCursor;
+        // During streaming, throttle re-renders unless the buffer actually changed
+        // (e.g., typing slash commands while streaming should update immediately).
+        const shouldThrottle = streamingActive &&
+            this.lastStreamingRender > 0 &&
+            !this.renderDirty &&
+            !bufferChanged &&
+            !this.showingSuggestions;
+        if (shouldThrottle) {
             const elapsed = Date.now() - this.lastStreamingRender;
             const waitMs = Math.max(0, this.streamingRenderInterval - elapsed);
             if (waitMs > 0) {
@@ -739,9 +779,7 @@ export class TerminalInput extends EventEmitter {
                 return;
             }
         }
-        const shouldSkip = !this.renderDirty &&
-            this.buffer === this.lastRenderContent &&
-            this.cursor === this.lastRenderCursor;
+        const shouldSkip = !this.renderDirty && !bufferChanged;
         this.renderDirty = false;
         if (shouldSkip) {
             return;
@@ -761,6 +799,8 @@ export class TerminalInput extends EventEmitter {
         const { rows, cols } = this.getSize();
         const maxWidth = Math.max(8, cols - 4);
         const streamingActive = this.mode === 'streaming' || isStreamingMode();
+        const prevChatBoxStart = this.lastChatBoxStartRow;
+        const prevChatBoxHeight = this.lastChatBoxHeight;
         // Wrap buffer into display lines
         const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
         const maxVisible = Math.max(1, Math.min(this.config.maxLines, rows - 3));
@@ -795,13 +835,16 @@ export class TerminalInput extends EventEmitter {
             if (this.scrollRegionActive) {
                 this.write(ESC.RESET_SCROLL);
             }
-            // Clear the chat box area
-            for (let i = 0; i < chatBoxHeight; i++) {
-                const row = chatBoxStartRow + i;
-                if (row <= rows) {
-                    this.write(ESC.TO(row, 1));
-                    this.write(ESC.CLEAR_LINE);
-                }
+            // Clear the current and previous chat box footprint to avoid ghost text when the height shrinks
+            const prevHeight = prevChatBoxStart !== null ? Math.max(1, prevChatBoxHeight) : chatBoxHeight;
+            const prevStart = prevChatBoxStart ?? chatBoxStartRow;
+            const prevEnd = prevStart + prevHeight - 1;
+            const newEnd = chatBoxStartRow + chatBoxHeight - 1;
+            const clearStart = Math.max(1, Math.min(prevStart, chatBoxStartRow));
+            const clearEnd = Math.min(rows, Math.max(prevEnd, newEnd));
+            for (let row = clearStart; row <= clearEnd; row++) {
+                this.write(ESC.TO(row, 1));
+                this.write(ESC.CLEAR_LINE);
             }
             let currentRow = chatBoxStartRow;
             // Render scroll/status indicator on the left (Claude Code style)
@@ -812,6 +855,13 @@ export class TerminalInput extends EventEmitter {
                 this.write(metaLine);
                 currentRow += 1;
             }
+            // Recent actions strip (sits above the divider)
+            const recentLines = this.buildRecentActionLines(cols - 2);
+            for (const recentLine of recentLines) {
+                this.write(ESC.TO(currentRow, 1));
+                this.write(recentLine);
+                currentRow += 1;
+            }
             // Separator line with scroll status
             this.write(ESC.TO(currentRow, 1));
             const dividerLabel = scrollIndicator || undefined;
@@ -1080,24 +1130,33 @@ export class TerminalInput extends EventEmitter {
             const contextTone = this.contextUsage > 80 ? 'warn' : this.contextUsage > 60 ? 'info' : 'muted';
             toggleParts.push({ text: `ctx:${remaining}%`, tone: contextTone });
         }
-        // Verification toggle (Alt+V)
-        const verifyStatus = this.verificationEnabled ? '✓' : '○';
+        const verifyHotkey = this.formatHotkey(this.verificationHotkey);
+        const verifyStatus = this.verificationEnabled ? 'Verify on' : 'Verify off';
         toggleParts.push({
-            text: `⌥V:${verifyStatus}verify`,
+            text: `${verifyHotkey} ${verifyStatus}`,
             tone: this.verificationEnabled ? 'success' : 'muted'
         });
-        // Auto-continue toggle (Alt+C)
-        const autoStatus = this.autoContinueEnabled ? '↻' : '○';
+        const autoHotkey = this.formatHotkey(this.autoContinueHotkey);
+        const autoStatus = this.autoContinueEnabled ? 'Auto-continue on' : 'Auto-continue off';
         toggleParts.push({
-            text: `⌥C:${autoStatus}auto`,
+            text: `${autoHotkey} ${autoStatus}`,
             tone: this.autoContinueEnabled ? 'info' : 'muted'
         });
-        // Thinking mode toggle (Alt+T)
+        // AlphaZero RL mode toggle
+        const alphaHotkey = this.formatHotkey(this.alphaZeroHotkey);
+        const alphaLabel = this.alphaZeroLabel || 'AlphaZero RL';
+        const alphaStatus = this.alphaZeroModeEnabled ? `${alphaLabel} on` : `${alphaLabel} off`;
+        toggleParts.push({
+            text: `${alphaHotkey} ${alphaStatus}`,
+            tone: this.alphaZeroModeEnabled ? 'success' : 'muted',
+        });
+        // Thinking mode toggle
         if (this.thinkingModeLabel) {
             const shortThinking = this.thinkingModeLabel.length > 10
                 ? this.thinkingModeLabel.slice(0, 8) + '..'
                 : this.thinkingModeLabel;
-            toggleParts.push({ text: `⌥T:${shortThinking}`, tone: 'info' });
+            const thinkingHotkey = this.formatHotkey(this.thinkingHotkey);
+            toggleParts.push({ text: `${thinkingHotkey} Thinking ${shortThinking}`, tone: 'info' });
         }
         // Navigation shortcuts - always show these
         toggleParts.push({ text: 'PgUp/Dn:scroll', tone: 'muted' });
@@ -1156,24 +1215,28 @@ export class TerminalInput extends EventEmitter {
             return hotkey;
         const parts = normalized.split('+').filter(Boolean);
         const map = {
-            shift: '⇧',
-            sh: '⇧',
-            alt: '⌥',
-            option: '⌥',
-            opt: '⌥',
-            ctrl: '⌃',
-            control: '⌃',
-            cmd: '⌘',
-            meta: '⌘',
+            shift: 'Shift',
+            sh: 'Shift',
+            alt: 'Alt',
+            option: 'Alt',
+            opt: 'Alt',
+            ctrl: 'Ctrl',
+            control: 'Ctrl',
+            cmd: 'Cmd',
+            meta: 'Cmd',
         };
         const formatted = parts
             .map((part) => {
             const symbol = map[part];
             if (symbol)
                 return symbol;
-            return part.length === 1 ? part.toUpperCase() : part.toUpperCase();
+            if (part.startsWith('/'))
+                return part;
+            if (part.length === 1)
+                return part.toUpperCase();
+            return part.charAt(0).toUpperCase() + part.slice(1);
         })
-            .join('');
+            .join('+');
         return formatted || hotkey;
     }
     computeContextRemaining() {
@@ -1213,6 +1276,41 @@ export class TerminalInput extends EventEmitter {
         const ansiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
         return value.replace(ansiPattern, '').length;
     }
+    /**
+     * Record a compact recent action for display above the divider.
+     */
+    recordRecentAction(action) {
+        const clean = this.sanitize(action).replace(/\s+/g, ' ').trim();
+        if (!clean) {
+            return;
+        }
+        const maxLen = 80;
+        const text = clean.length > maxLen ? `${clean.slice(0, maxLen - 1)}…` : clean;
+        const last = this.recentActions[this.recentActions.length - 1];
+        if (last && last.text === text) {
+            last.timestamp = Date.now();
+            return;
+        }
+        if (!this.isTTY()) {
+            this.write(`[action] ${text}\n`);
+        }
+        this.recentActions.push({ text, timestamp: Date.now() });
+        while (this.recentActions.length > this.maxRecentActions) {
+            this.recentActions.shift();
+        }
+        this.scheduleRender();
+    }
+    /**
+     * Build the single-line recent actions strip.
+     */
+    buildRecentActionLines(width) {
+        if (this.recentActions.length === 0 || width <= 0) {
+            return [];
+        }
+        const items = this.recentActions.map((entry) => ({ text: entry.text, tone: 'muted' }));
+        const parts = [{ text: 'recent', tone: 'info' }, ...items];
+        return [renderStatusLine(parts, width)];
+    }
     /**
      * Debug-only snapshot used by tests to assert rendered strings without
      * needing a TTY. Not used by production code.
@@ -1259,6 +1357,12 @@ export class TerminalInput extends EventEmitter {
      * Sets up terminal scroll region to exclude chat box.
      */
     enterStreamingScrollRegion() {
+        if (!this.isTTY()) {
+            this.scrollRegionActive = false;
+            this.setStatusMessage('esc to interrupt');
+            this.forceRender();
+            return;
+        }
         const { rows } = this.getSize();
         const chatBoxHeight = this.getChatBoxHeight();
         const scrollEnd = Math.max(1, rows - chatBoxHeight);
@@ -1282,6 +1386,12 @@ export class TerminalInput extends EventEmitter {
      * Clears the old pinned chat box area to prevent duplication.
      */
     exitStreamingScrollRegion() {
+        if (!this.isTTY()) {
+            this.scrollRegionActive = false;
+            this.setStatusMessage('Ready for prompts');
+            this.forceRender();
+            return;
+        }
         const { rows } = this.getSize();
         const chatBoxHeight = this.getChatBoxHeight();
         writeLock.lock('exitStreamingScrollRegion');
@@ -1336,8 +1446,16 @@ export class TerminalInput extends EventEmitter {
         finally {
             writeLock.unlock();
         }
-        // Throttle chat box updates during streaming
-        this.scheduleStreamingRender(200);
+        // Throttle chat box updates only when a re-render is needed.
+        // In streaming mode the chat box stays pinned, so skip redundant redraws.
+        const needsRender = !this.scrollRegionActive || this.renderDirty;
+        if (needsRender) {
+            if (!this.scrollRegionActive) {
+                // Content moved; force a render so the chat box follows.
+                this.renderDirty = true;
+            }
+            this.scheduleStreamingRender(150);
+        }
     }
     /**
      * Enable scroll region (no-op in floating mode).
@@ -1380,9 +1498,11 @@ export class TerminalInput extends EventEmitter {
             const filtered = this.getFilteredCommands();
             suggestionLines = Math.min(filtered.length, this.maxVisibleSuggestions) + 1; // +1 for header
         }
+        // Recent actions strip (single line when present)
+        const recentLines = this.buildRecentActionLines(cols - 2).length;
         // Total: meta + divider + input lines + suggestions + controls + buffer
         // Leave a small buffer so streamed content still has space above the chat box
-        const totalHeight = metaLines + 1 + inputLines + suggestionLines + controlLineCount + 1;
+        const totalHeight = metaLines + recentLines + 1 + inputLines + suggestionLines + controlLineCount + 1;
         const minContentRows = 2;
         const maxHeight = Math.max(4, rows - minContentRows);
         return Math.min(totalHeight, maxHeight);
@@ -1417,6 +1537,12 @@ export class TerminalInput extends EventEmitter {
             return;
         // Capture content in scrollback buffer
         this.addToScrollback(content);
+        if (!this.isTTY()) {
+            this.write(content);
+            const rowsUsed = this.countRenderedRows(content);
+            this.contentRow += rowsUsed;
+            return;
+        }
         writeLock.lock('writeToScrollRegion');
         try {
             // Position cursor at content row and write
@@ -1531,33 +1657,76 @@ export class TerminalInput extends EventEmitter {
                 else {
                     this.emit('interrupt');
                 }
-                break;
+                return true;
             case 'a': // Home
+                if (key.shift) {
+                    this.emit('toggleAlphaZero');
+                    return true;
+                }
                 this.moveCursorToLineStart();
-                break;
+                return true;
             case 'e': // End
+                if (key.shift) {
+                    this.toggleEditMode();
+                    this.emit('toggleEditMode');
+                    return true;
+                }
                 this.moveCursorToLineEnd();
-                break;
+                return true;
             case 'u': // Delete to start
                 this.deleteToStart();
-                break;
+                return true;
             case 'k': // Delete to end
                 this.deleteToEnd();
-                break;
+                return true;
             case 'w': // Delete word
                 this.deleteWord();
-                break;
+                return true;
             case 'left': // Word left
                 this.moveCursorWordLeft();
-                break;
+                return true;
             case 'right': // Word right
                 this.moveCursorWordRight();
+                return true;
+            case 'return': // Ctrl+Enter => newline instead of submit
+                this.insertNewline();
+                return true;
+            case 'v':
+                if (key.shift) {
+                    this.emit('toggleVerify');
+                    return true;
+                }
+                break;
+            case 'c':
+                if (key.shift) {
+                    this.emit('toggleAutoContinue');
+                    return true;
+                }
+                break;
+            case 't':
+                if (key.shift) {
+                    this.emit('toggleThinking');
+                    return true;
+                }
+                break;
+            case 'x':
+                if (key.shift) {
+                    this.emit('clearContext');
+                    return true;
+                }
+                break;
+            case 's':
+                if (key.shift) {
+                    this.toggleScrollbackMode();
+                    return true;
+                }
                 break;
         }
+        return false;
     }
     /**
      * Handle Alt/Meta key combinations for mode toggles and navigation.
-     * All major erosolar-cli features accessible via keyboard shortcuts.
+     * Ctrl-based shortcuts are primary; Alt/Meta remains as a compatibility fallback.
      */
     handleMetaKey(key) {
         switch (key.name) {
@@ -1589,6 +1758,10 @@ export class TerminalInput extends EventEmitter {
                 // Alt+T: Toggle/cycle thinking mode
                 this.emit('toggleThinking');
                 break;
+            case 'a':
+                // Alt+A: Toggle AlphaZero RL mode
+                this.emit('toggleAlphaZero');
+                break;
             case 'e':
                 // Alt+E: Toggle edit permission mode (ask/auto)
                 this.toggleEditMode();
@@ -1656,12 +1829,12 @@ export class TerminalInput extends EventEmitter {
     handleSpecialKey(_str, key) {
         switch (key.name) {
             case 'return':
-                if (key.shift || key.meta) {
+                if (key.shift || key.meta || key.ctrl) {
                     this.insertNewline();
                 }
                 else if (this.showingSuggestions) {
-                    // Select suggestion and don't submit yet
-                    this.selectSuggestion();
+                    // Select highlighted suggestion and submit immediately
+                    this.selectSuggestion({ submit: true });
                 }
                 else {
                     this.submit();
@@ -1748,7 +1921,7 @@ export class TerminalInput extends EventEmitter {
                 // Scrollback disabled in alternate screen mode
                 return true;
             case 'tab':
-                // Tab can select suggestion too
+                // Tab can select suggestion too without submitting
                 if (this.showingSuggestions && !key.shift) {
                     this.selectSuggestion();
                     return true;
@@ -2184,7 +2357,7 @@ export class TerminalInput extends EventEmitter {
         this.isInScrollbackMode = false;
     }
     /**
-     * Toggle scrollback mode on/off (Alt+S hotkey)
+     * Toggle scrollback mode on/off (Ctrl+Shift+S hotkey; Alt+S legacy)
      * DISABLED: Scrollback navigation causes display corruption in alternate screen mode.
      */
     toggleScrollbackMode() {
@@ -2440,13 +2613,38 @@ export class TerminalInput extends EventEmitter {
             this.streamingRenderTimer = null;
             // During streaming, only update chat box (not full render)
             if (this.scrollRegionActive) {
-                this.renderChatBoxAtBottom();
+                this.renderStreamingFrame();
             }
             else {
                 this.render();
             }
         }, wait);
     }
+    /**
+     * Render the pinned chat box during streaming only when we actually have
+     * pending UI changes. Prevents meta/header lines from being echoed into the
+     * streamed log when nothing changed.
+     */
+    renderStreamingFrame(force = false) {
+        if (!this.canRender())
+            return;
+        if (this.isRendering)
+            return;
+        const shouldSkip = !force &&
+            !this.renderDirty &&
+            this.buffer === this.lastRenderContent &&
+            this.cursor === this.lastRenderCursor;
+        // Clear the dirty flag even when skipping to avoid runaway retries.
+        this.renderDirty = false;
+        if (shouldSkip) {
+            return;
+        }
+        if (writeLock.isLocked()) {
+            writeLock.safeWrite(() => this.renderStreamingFrame(force));
+            return;
+        }
+        this.renderPinnedChatBox();
+    }
     resetStreamingRenderThrottle() {
         if (this.streamingRenderTimer) {
             clearTimeout(this.streamingRenderTimer);
@@ -2458,7 +2656,14 @@ export class TerminalInput extends EventEmitter {
         if (!this.canRender())
             return;
         this.renderDirty = true;
-        queueMicrotask(() => this.render());
+        queueMicrotask(() => {
+            const streamingActive = this.scrollRegionActive || this.mode === 'streaming' || isStreamingMode();
+            if (streamingActive && this.scrollRegionActive) {
+                this.renderStreamingFrame();
+                return;
+            }
+            this.render();
+        });
     }
     canRender() {
         return !this.disposed && this.enabled && this.isTTY();
@@ -2489,7 +2694,7 @@ export class TerminalInput extends EventEmitter {
         return text
             .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '') // OSC sequences
             .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '') // CSI sequences
-            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '') // Control chars except \n and \r
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '') // Control chars except \n and \r (incl. DEL/C1)
             .replace(/\r\n?/g, '\n'); // Normalize line endings
     }
     getArrowKeyName(sequence) {
@@ -2523,6 +2728,11 @@ export class TerminalInput extends EventEmitter {
     isOrphanedEscapeSequence(text, key) {
         if (!text || key?.name)
             return false;
+        // If sanitizing leaves printable content, treat it as user input.
+        const sanitized = this.sanitize(text);
+        if (sanitized.length > 0) {
+            return false;
+        }
         if (text.includes('\x1b'))
             return true;
         // Common stray fragments when terminals partially echo arrow sequences (e.g., "[D")