induscode 0.1.0__py3-none-any.whl

induscode/console/input/__init__.py

@@ -0,0 +1,107 @@
+"""Console input — public barrel for the composer-input modules (M5 wave 1).
+
+Port of TS ``src/console/input`` (``keymap.ts`` / ``complete.ts`` /
+``dir-reader.ts`` / ``index.ts``), reshaped around the framework editor per
+the port plan (analysis 02 §6):
+
+- **intents** — the :data:`ConsoleVerb` vocabulary (TS verbatim) split into
+  the app-level chord→intent :data:`INTENT_TABLE` (the data the wave-3
+  ``ConsoleApp`` BINDINGS derive from) and the :data:`EDITOR_DELEGATED` map
+  documenting which TS verbs collapsed into the framework
+  ``EditorKeybindingsManager``/``EditorCore``. The TS ``readKey``
+  classifier itself is not ported — Textual + the framework key decoder do
+  that job.
+- **chord** — the double-tap latch (:func:`advance_chord`: Esc×2,
+  Ctrl+U×2) ported verbatim, plus the Ctrl+C exit window
+  (:func:`advance_exit_window`) extracted from the TS surface as a pure
+  helper with an injectable clock. The app owns the live latch values and
+  the timers.
+- **providers** — the slash + ``@``/path completion engine
+  (:func:`complete_at` / :func:`apply_suggestion`, pure and verbatim) and
+  its framework ``AutocompleteProvider`` adapters
+  (:class:`ConsoleAutocompleteProvider` et al.) feeding ``PromptEditor``.
+- **dir_reader** — the live ``os.scandir`` binding of the
+  :data:`DirReader` seam.
+
+TS ``paste.ts`` is **deleted by design**: the paste vault, the
+``‹clip N · K lines›`` markers, the burst debounce, and the
+bracketed-paste stripping all collapse into the framework
+``EditorCore`` paste markers + Textual's native ``events.Paste``
+(pinned in ``tests/console/test_input.py``).
+"""
+
+from .chord import (
+    CHORD_VERBS,
+    CHORD_WINDOW_MS,
+    CTRL_C_EXIT_WINDOW_MS,
+    ChordLatch,
+    ChordOutcome,
+    ChordStep,
+    ExitAction,
+    ExitStep,
+    ExitWindow,
+    NO_CHORD,
+    NO_EXIT_WINDOW,
+    advance_chord,
+    advance_exit_window,
+)
+from .dir_reader import DirEntry, DirReader, create_dir_reader
+from .intents import (
+    CONSOLE_VERBS,
+    ConsoleIntent,
+    ConsoleVerb,
+    EDITOR_DELEGATED,
+    INTENT_TABLE,
+    NO_INTENT,
+)
+from .providers import (
+    AppliedSuggestion,
+    CompletionKind,
+    CompletionResult,
+    ConsoleAutocompleteProvider,
+    PathCompletionProvider,
+    SlashCommandProvider,
+    Suggestion,
+    TokenSpan,
+    active_token,
+    apply_suggestion,
+    complete_at,
+    to_autocomplete_item,
+)
+
+__all__ = [
+    "AppliedSuggestion",
+    "CHORD_VERBS",
+    "CHORD_WINDOW_MS",
+    "CONSOLE_VERBS",
+    "CTRL_C_EXIT_WINDOW_MS",
+    "ChordLatch",
+    "ChordOutcome",
+    "ChordStep",
+    "CompletionKind",
+    "CompletionResult",
+    "ConsoleAutocompleteProvider",
+    "ConsoleIntent",
+    "ConsoleVerb",
+    "DirEntry",
+    "DirReader",
+    "EDITOR_DELEGATED",
+    "ExitAction",
+    "ExitStep",
+    "ExitWindow",
+    "INTENT_TABLE",
+    "NO_CHORD",
+    "NO_EXIT_WINDOW",
+    "NO_INTENT",
+    "PathCompletionProvider",
+    "SlashCommandProvider",
+    "Suggestion",
+    "TokenSpan",
+    "active_token",
+    "advance_chord",
+    "advance_exit_window",
+    "apply_suggestion",
+    "complete_at",
+    "create_dir_reader",
+    "to_autocomplete_item",
+]

induscode/console/input/chord.py

@@ -0,0 +1,197 @@
+"""Chord latching — the stateful layer over the pure intent vocabulary.
+
+Two small pure machines the wave-3 ``ConsoleApp`` owns the live values of:
+
+1. **The double-tap latch** (TS ``keymap.ts`` ``advanceChord`` — verbatim).
+   A first tap of ``flow:dismiss`` (Escape) primes a chord; a second tap
+   within the surface's window fires ``dismiss×2`` (the configurable
+   double-Escape action: tree / fork / clear). A first tap of
+   ``edit:clearLine`` (Ctrl+U on an already-empty buffer) primes a chord
+   whose second tap fires ``clear×2`` (request exit). Any other intent
+   breaks the latch. :func:`advance_chord` is pure; the app owns the latch
+   value and the :data:`CHORD_WINDOW_MS` timer that expires it (simply
+   resetting to :data:`NO_CHORD` — ``App.set_timer`` in Textual).
+
+2. **The Ctrl+C exit window** (TS ``TerminalConsole.tsx`` ``flow:interrupt``
+   case — extracted here as a pure helper with an injectable clock).
+   Ctrl+C is clear-then-exit: a busy turn is aborted first; otherwise a
+   press on a non-empty buffer clears it, and a press on an empty buffer
+   arms a window — a second empty-buffer press within
+   :data:`CTRL_C_EXIT_WINDOW_MS` asks the host to leave.
+   :func:`advance_exit_window` folds one press into the carried
+   :class:`ExitWindow`; the caller injects ``now_ms`` (the clock seam), so
+   the whole machine is deterministic under test.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Literal, Mapping, TypeAlias
+
+from .intents import ConsoleIntent
+
+__all__ = [
+    "CHORD_VERBS",
+    "CHORD_WINDOW_MS",
+    "CTRL_C_EXIT_WINDOW_MS",
+    "ChordLatch",
+    "ChordOutcome",
+    "ChordStep",
+    "ExitAction",
+    "ExitStep",
+    "ExitWindow",
+    "NO_CHORD",
+    "NO_EXIT_WINDOW",
+    "advance_chord",
+    "advance_exit_window",
+]
+
+
+# ---------------------------------------------------------------------------
+# Double-tap latch (TS ``advanceChord`` — verbatim)
+# ---------------------------------------------------------------------------
+
+#: How long a primed double-tap chord stays armed before the surface expires
+#: it back to :data:`NO_CHORD` (TS ``CHORD_WINDOW_MS``).
+CHORD_WINDOW_MS = 600
+
+#: Which verbs participate in a double-tap chord, and what a repeat fires.
+ChordOutcome: TypeAlias = Literal["dismiss×2", "clear×2"]
+
+#: The verbs that can prime a chord, mapped to the outcome a repeat fires.
+CHORD_VERBS: Mapping[str, ChordOutcome] = MappingProxyType(
+    {
+        "flow:dismiss": "dismiss×2",
+        "edit:clearLine": "clear×2",
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ChordLatch:
+    """The cross-keystroke latch the surface carries between key events.
+
+    ``armed`` is the verb a prior keystroke primed (or ``None`` when no
+    chord is in flight). The surface resets it to ``None`` when its timeout
+    expires.
+    """
+
+    # The verb a previous keystroke armed, or ``None`` when nothing is primed.
+    armed: str | None = None
+
+
+#: A fresh, unarmed latch.
+NO_CHORD = ChordLatch()
+
+
+@dataclass(frozen=True, slots=True)
+class ChordStep:
+    """The result of folding a fresh intent into the prior chord latch."""
+
+    # The latch to carry into the next keystroke.
+    next: ChordLatch
+    # The chord that fired on this keystroke, or ``None`` if none did.
+    fired: ChordOutcome | None
+
+
+def advance_chord(latch: ChordLatch, intent: ConsoleIntent) -> ChordStep:
+    """Fold a fresh :class:`ConsoleIntent` into the prior :class:`ChordLatch`.
+
+    Pure: given the same latch and intent it always yields the same step. If
+    the incoming verb matches the armed verb and that verb is
+    chord-eligible, the chord fires and the latch resets. If the incoming
+    verb is chord-eligible but the latch was empty (or armed with a
+    different verb), it arms. Any other intent clears the latch. The timeout
+    that expires a stale latch is the surface's responsibility (it simply
+    resets to :data:`NO_CHORD`).
+
+    :param latch:  the latch carried from the previous keystroke
+    :param intent: the freshly classified intent for this keystroke
+    """
+    outcome = CHORD_VERBS.get(intent.verb)
+    if outcome is None:
+        # Non-chord key: drop any primed chord.
+        return ChordStep(next=NO_CHORD, fired=None)
+    if latch.armed == intent.verb:
+        # Second matching tap — fire and disarm.
+        return ChordStep(next=NO_CHORD, fired=outcome)
+    # First tap of a chord-eligible key — arm it.
+    return ChordStep(next=ChordLatch(armed=intent.verb), fired=None)
+
+
+# ---------------------------------------------------------------------------
+# Ctrl+C exit window (TS ``flow:interrupt`` case, as a pure machine)
+# ---------------------------------------------------------------------------
+
+#: How long after an empty-buffer Ctrl+C a second press still exits
+#: (TS ``CTRL_C_EXIT_WINDOW_MS``).
+CTRL_C_EXIT_WINDOW_MS = 500
+
+#: What one Ctrl+C press does, in TS branch order: abort a busy turn, clear
+#: a non-empty buffer, arm the window on the first empty-buffer press, exit
+#: on the second within the window.
+ExitAction: TypeAlias = Literal["abort", "clear", "arm", "exit"]
+
+
+@dataclass(frozen=True, slots=True)
+class ExitWindow:
+    """The carried Ctrl+C latch: when (ms) the window was armed, or ``None``
+    when unarmed. The TS code kept a raw timestamp ref initialized to ``0``
+    as the unarmed sentinel; ``None`` expresses the same state without the
+    epoch hack."""
+
+    armed_at_ms: float | None = None
+
+
+#: A fresh, unarmed exit window.
+NO_EXIT_WINDOW = ExitWindow()
+
+
+@dataclass(frozen=True, slots=True)
+class ExitStep:
+    """The result of folding one Ctrl+C press into the carried window."""
+
+    # The window to carry into the next press.
+    next: ExitWindow
+    # What the surface should do for this press.
+    action: ExitAction
+
+
+def advance_exit_window(
+    window: ExitWindow,
+    *,
+    busy: bool,
+    buffer_empty: bool,
+    now_ms: float,
+    window_ms: float = CTRL_C_EXIT_WINDOW_MS,
+) -> ExitStep:
+    """Fold one Ctrl+C press into the prior :class:`ExitWindow`.
+
+    Pure, with the clock injected as ``now_ms`` (the caller supplies its
+    monotonic-ms reading; tests supply literals). Branch order is the TS
+    handler's exactly:
+
+    - a **busy** turn is aborted and the window disarms (the press never
+      doubles as an exit step);
+    - an **empty buffer**: a press within ``window_ms`` of the armed
+      timestamp fires ``exit`` and disarms; otherwise it (re-)arms at
+      ``now_ms``;
+    - a **non-empty buffer**: the press clears the composer and disarms —
+      the window is only ever armed by a press that left an empty buffer
+      untouched.
+
+    :param window:       the window carried from the previous press
+    :param busy:         whether a turn is currently in flight
+    :param buffer_empty: whether the composer buffer is empty
+    :param now_ms:       the injected clock reading, in milliseconds
+    :param window_ms:    the exit window width (defaults to
+        :data:`CTRL_C_EXIT_WINDOW_MS`)
+    """
+    if busy:
+        return ExitStep(next=NO_EXIT_WINDOW, action="abort")
+    if not buffer_empty:
+        return ExitStep(next=NO_EXIT_WINDOW, action="clear")
+    if window.armed_at_ms is not None and now_ms - window.armed_at_ms <= window_ms:
+        return ExitStep(next=NO_EXIT_WINDOW, action="exit")
+    return ExitStep(next=ExitWindow(armed_at_ms=now_ms), action="arm")

induscode/console/input/dir_reader.py

@@ -0,0 +1,113 @@
+"""Directory reader — the live ``os.scandir``-backed :data:`DirReader`.
+
+Port of TS ``src/console/input/dir-reader.ts``. The completion engine
+(:func:`induscode.console.input.providers.complete_at`) is pure: its path
+branch lists a directory through an injected :data:`DirReader` rather than
+touching the disk itself, so the suggestion logic stays unit-testable
+against a synthetic tree. This module is the one place that binds that seam
+to a real filesystem.
+
+:func:`create_dir_reader` returns a reader that resolves a (possibly
+relative) directory path against a base directory — the session working
+directory by default — and lists its immediate entries as :class:`DirEntry`
+records. Every failure mode (a missing directory, a permission error, a
+path that names a file) collapses to an empty list, so the composer never
+raises while the user is mid-type. A symlink is classified by whether it
+ultimately resolves to a directory, falling back to non-directory when the
+target cannot be stat-ed (the TS ``statSync`` fallback, exactly).
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import TypeAlias
+
+__all__ = [
+    "DirEntry",
+    "DirReader",
+    "create_dir_reader",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class DirEntry:
+    """One pure directory-listing row: a leaf name, flagged dir-or-file."""
+
+    # The leaf name (no path separators).
+    name: str
+    # Whether the entry is a directory (symlinks resolved; see module doc).
+    is_dir: bool
+
+
+#: An injected directory listing so the path-completion branch stays pure
+#: and testable. Given a directory path (relative to the working dir), it
+#: returns that directory's immediate entries, or an empty list when the
+#: path does not exist or cannot be read. The live console binds this to
+#: :func:`create_dir_reader`; tests bind it to a synthetic tree.
+DirReader: TypeAlias = Callable[[str], Sequence[DirEntry]]
+
+
+def _entry_is_dir(base: str, name: str, is_dirent: bool, is_symlink: bool) -> bool:
+    """Decide whether a listed entry should be treated as a directory.
+
+    A plain directory dirent answers immediately. A symlink is followed with
+    a ``stat`` so a link to a directory completes with a trailing slash; if
+    the link target cannot be resolved (dangling, permission), the entry is
+    reported as a non-directory rather than raising.
+    """
+    if is_dirent:
+        return True
+    if not is_symlink:
+        return False
+    try:
+        return stat.S_ISDIR(os.stat(os.path.join(base, name)).st_mode)
+    except OSError:
+        return False
+
+
+def _resolve(base: str, dir_path: str) -> str:
+    """``path.resolve(cwd, dirPath)`` parity: an absolute request is used
+    as-is, a relative one is joined onto the base directory."""
+    if os.path.isabs(dir_path):
+        return os.path.normpath(dir_path)
+    return os.path.normpath(os.path.join(base, dir_path))
+
+
+def create_dir_reader(cwd: str | None = None) -> DirReader:
+    """Build a live :data:`DirReader` rooted at ``cwd``.
+
+    The returned reader resolves each requested directory path against
+    ``cwd`` (an absolute request is used as-is), lists it, and maps each
+    child to a :class:`DirEntry`. Any error returns ``[]``.
+
+    :param cwd: the base directory relative requests resolve against
+        (defaults to the process working directory, captured here)
+    """
+    base = cwd if cwd is not None else os.getcwd()
+
+    def read(dir_path: str) -> Sequence[DirEntry]:
+        target = _resolve(base, dir_path)
+        try:
+            with os.scandir(target) as scan:
+                dirents = list(scan)
+        except OSError:
+            return []
+        entries: list[DirEntry] = []
+        for dirent in dirents:
+            try:
+                is_dirent = dirent.is_dir(follow_symlinks=False)
+                is_symlink = dirent.is_symlink()
+            except OSError:
+                is_dirent, is_symlink = False, False
+            entries.append(
+                DirEntry(
+                    name=dirent.name,
+                    is_dir=_entry_is_dir(target, dirent.name, is_dirent, is_symlink),
+                )
+            )
+        return entries
+
+    return read

induscode/console/input/intents.py

@@ -0,0 +1,258 @@
+"""Console intents — the keystroke-verb vocabulary and the chord→intent table.
+
+Port of the *vocabulary* half of TS ``src/console/input/keymap.ts``. The TS
+console classified raw Ink ``(input, key)`` events through a pure ``readKey``
+into :class:`ConsoleIntent` verbs; in the Python console most of that
+classifier **collapses into the framework**:
+
+- Editor-level verbs (typing, deletion, caret motion, history, submit,
+  completion accept) are delegated to
+  :class:`indusagi.tui.keybindings.EditorKeybindingsManager` +
+  :class:`indusagi.tui.editor.EditorCore`, driven by the framework
+  ``PromptEditor`` widget. :data:`EDITOR_DELEGATED` documents the exact
+  verb → ``EditorAction`` mapping, as data, so the delegation is pinned by
+  tests rather than prose.
+- App-level verbs survive as :data:`INTENT_TABLE` — a chord → intent map in
+  the framework's ``KeyId`` vocabulary (``indusagi.tui.keys``). The wave-3
+  ``ConsoleApp`` derives its Textual ``BINDINGS``/``action_*`` methods from
+  this table; the table itself stays pure data so the chord→verb matrix is
+  unit-tested without mounting Textual.
+
+The verb strings are the TS union **verbatim** (they are user-visible in
+``/keys`` and stay byte-identical); the chord spellings move from Ink's flag
+bag to ``KeyId`` strings (``ctrl+r``, ``shift+tab``, ``alt+up``, ...), which
+is the re-pinning analysis 02 risk-5 calls for.
+
+Ink-specific quirks the framework dissolves (deliberately NOT ported):
+
+- the macOS Backspace-as-``key.delete`` fold and the raw DEL/BS control
+  bytes — ``indusagi.tui.keys`` already maps ``\\x7f``/``\\x08`` to
+  ``backspace``, so ``edit:erasePrev`` needs no quirk table;
+- the printable-vs-control-byte filter (``isPrintable``) — Textual's
+  ``events.Key.is_printable`` plays that role inside ``PromptEditor``;
+- bracketed-paste delimiter stripping and the paste burst — Textual delivers
+  one assembled ``events.Paste`` (see ``tests/console/test_input.py`` §3).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Literal, Mapping, TypeAlias
+
+__all__ = [
+    "CONSOLE_VERBS",
+    "ConsoleIntent",
+    "ConsoleVerb",
+    "EDITOR_DELEGATED",
+    "INTENT_TABLE",
+    "NO_INTENT",
+]
+
+
+# ---------------------------------------------------------------------------
+# Console verb vocabulary (TS ``ConsoleVerb`` — verbatim)
+# ---------------------------------------------------------------------------
+
+#: The console's own keystroke-intent verbs. Deliberately *not* a mirror of
+#: any upstream keybinding enum: each verb names what the console does,
+#: grouped by concern (editing / caret / session control / model / queue /
+#: input sources / overlays / view toggles / inert). Strings are the TS
+#: union verbatim.
+ConsoleVerb: TypeAlias = Literal[
+    # Editing
+    "text:type",
+    "text:newline",
+    "edit:erasePrev",
+    "edit:eraseNext",
+    "edit:clearLine",
+    # Caret / navigation
+    "nav:left",
+    "nav:right",
+    "nav:home",
+    "nav:end",
+    "nav:up",
+    "nav:down",
+    # Session control
+    "flow:submit",
+    "flow:dismiss",
+    "flow:accept",
+    "flow:interrupt",
+    "flow:suspend",
+    "flow:cycleModel",
+    # Model / reasoning
+    "model:cycleThinking",
+    # Queue
+    "queue:dequeue",
+    # Input sources
+    "input:pasteImage",
+    "input:externalEditor",
+    # Overlays
+    "overlay:open",
+    # View toggles
+    "view:expandTools",
+    "view:toggleReasoning",
+    # Inert
+    "none",
+]
+
+#: Runtime mirror of the :data:`ConsoleVerb` union, in declaration order —
+#: the coverage anchor for the union test (exhaustiveness via tests, not
+#: types; cross-cutting rule 1).
+CONSOLE_VERBS: tuple[str, ...] = (
+    "text:type",
+    "text:newline",
+    "edit:erasePrev",
+    "edit:eraseNext",
+    "edit:clearLine",
+    "nav:left",
+    "nav:right",
+    "nav:home",
+    "nav:end",
+    "nav:up",
+    "nav:down",
+    "flow:submit",
+    "flow:dismiss",
+    "flow:accept",
+    "flow:interrupt",
+    "flow:suspend",
+    "flow:cycleModel",
+    "model:cycleThinking",
+    "queue:dequeue",
+    "input:pasteImage",
+    "input:externalEditor",
+    "overlay:open",
+    "view:expandTools",
+    "view:toggleReasoning",
+    "none",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ConsoleIntent:
+    """A classified keystroke: a :data:`ConsoleVerb` plus the small payload a
+    verb may carry — the literal text for a ``text:type`` insert, or the
+    target overlay for an ``overlay:open``. Every other verb is
+    self-contained, so both payload fields default to ``None`` and are
+    present only on their owning verb.
+    """
+
+    # What the keystroke means to the console.
+    verb: ConsoleVerb
+    # The literal text to splice, present only for ``text:type``.
+    text: str | None = None
+    # The overlay to raise (a console ``ModalKind`` literal; the full union
+    # lands with the wave-2 console contract), present only for
+    # ``overlay:open``.
+    overlay: str | None = None
+
+
+#: The inert intent — a keystroke the console ignores.
+NO_INTENT = ConsoleIntent(verb="none")
+
+
+# ---------------------------------------------------------------------------
+# The intent table (app-level chords → intents, as data)
+# ---------------------------------------------------------------------------
+
+#: Key chord → :class:`ConsoleIntent`, in the framework ``KeyId`` spelling.
+#:
+#: This is the surviving app-level slice of the TS ``readKey`` matrix; the
+#: wave-3 ``ConsoleApp`` derives its Textual ``BINDINGS`` from these rows.
+#: Editor-level chords are absent by design — they are resolved inside the
+#: framework ``PromptEditor`` (see :data:`EDITOR_DELEGATED`) and never reach
+#: the app while the composer has focus.
+#:
+#: Two rows are deliberately dual-role:
+#:
+#: - ``escape`` → ``flow:dismiss``: while the autocomplete popup is open the
+#:   editor consumes Escape as ``selectCancel``; otherwise it bubbles to the
+#:   app, which dismisses an overlay / aborts a busy turn / feeds the
+#:   double-Esc chord latch (:func:`induscode.console.input.chord.advance_chord`).
+#: - ``ctrl+u`` → ``edit:clearLine``: the *editing* effect is the framework's
+#:   ``deleteToLineStart`` (readline unix-line-discard, editor-consumed);
+#:   the app additionally observes the chord on an already-empty buffer to
+#:   arm the ``clear×2`` exit latch, exactly like the TS console.
+INTENT_TABLE: Mapping[str, ConsoleIntent] = MappingProxyType(
+    {
+        # Session control.
+        "ctrl+c": ConsoleIntent(verb="flow:interrupt"),
+        "ctrl+z": ConsoleIntent(verb="flow:suspend"),
+        # Rotate the active model forward in scope (two chords, one verb —
+        # the TS table maps both ctrl+n and ctrl+p to the same rotation).
+        "ctrl+n": ConsoleIntent(verb="flow:cycleModel"),
+        "ctrl+p": ConsoleIntent(verb="flow:cycleModel"),
+        # Reasoning ladder + view toggles.
+        "shift+tab": ConsoleIntent(verb="model:cycleThinking"),
+        "ctrl+t": ConsoleIntent(verb="view:toggleReasoning"),
+        # The per-scope model picker is reached deliberately via
+        # /scoped-models, so this chord is free to toggle full tool-output
+        # rendering instead.
+        "ctrl+o": ConsoleIntent(verb="view:expandTools"),
+        # Input sources.
+        "ctrl+v": ConsoleIntent(verb="input:pasteImage"),
+        # The settings overlay is reached via /settings; this chord hands the
+        # composer buffer off to the user's external editor instead.
+        "ctrl+g": ConsoleIntent(verb="input:externalEditor"),
+        # Overlays raised directly from a control chord, without typing a
+        # slash command.
+        "ctrl+r": ConsoleIntent(verb="overlay:open", overlay="sessions"),
+        "ctrl+l": ConsoleIntent(verb="overlay:open", overlay="models"),
+        # Queue: pull the newest queued input back into the composer.
+        "alt+up": ConsoleIntent(verb="queue:dequeue"),
+        # Dual-role rows (see the table doc above).
+        "escape": ConsoleIntent(verb="flow:dismiss"),
+        "ctrl+u": ConsoleIntent(verb="edit:clearLine"),
+    }
+)
+
+
+# ---------------------------------------------------------------------------
+# Editor delegation (which TS verbs collapsed into the framework)
+# ---------------------------------------------------------------------------
+
+#: TS ``readKey`` verb → the framework ``EditorAction`` name(s) that absorb
+#: it (resolved by ``EditorKeybindingsManager``; dispatched by
+#: ``PromptEditor`` / ``EditorCore``). Expressed as data so the coverage
+#: test pins that every verb in :data:`CONSOLE_VERBS` is either an app
+#: intent, editor-delegated, or the inert ``none``.
+#:
+#: Notes on the non-obvious rows:
+#:
+#: - ``text:type`` has no named action — it is ``PromptEditor``'s printable-
+#:   character path (``EditorCore.insert_character``), which also absorbs the
+#:   TS ``isPrintable`` control-byte filter.
+#: - ``text:newline``: the bound chord is ``shift+enter``; the widget also
+#:   keeps the TS fallbacks (raw ``ctrl+j`` / ``alt+enter`` / a trailing
+#:   ``\\`` before Enter) for terminals without an extended protocol.
+#: - ``edit:erasePrev``: the framework key decoder folds ``\\x7f``/``\\x08``
+#:   into ``backspace``, so the TS macOS quirk table dies here.
+#: - ``edit:eraseNext`` had no chord in the TS matrix (the verb existed in
+#:   the vocabulary only); the framework gives it ``delete`` natively.
+#: - ``nav:home``/``nav:end``: the TS console collapsed PageUp/PageDown onto
+#:   buffer start/end; the framework editor gives PageUp/PageDown true
+#:   visual-page motion (``pageUp``/``pageDown`` actions) — a deliberate,
+#:   documented divergence (the richer behavior supersedes the collapse).
+#: - ``nav:up``/``nav:down`` are history-aware in ``EditorCore`` and double
+#:   as ``selectUp``/``selectDown`` while the completion popup is open.
+#: - ``flow:submit`` doubles as ``selectConfirm`` in the popup; ``flow:accept``
+#:   is the popup/Tab completion accept (``tab``); ``flow:dismiss`` is
+#:   editor-consumed only while the popup is open (``selectCancel``).
+EDITOR_DELEGATED: Mapping[str, tuple[str, ...]] = MappingProxyType(
+    {
+        "text:type": (),
+        "text:newline": ("newLine",),
+        "edit:erasePrev": ("deleteCharBackward",),
+        "edit:eraseNext": ("deleteCharForward",),
+        "edit:clearLine": ("deleteToLineStart",),
+        "nav:left": ("cursorLeft",),
+        "nav:right": ("cursorRight",),
+        "nav:home": ("cursorLineStart", "pageUp"),
+        "nav:end": ("cursorLineEnd", "pageDown"),
+        "nav:up": ("cursorUp", "selectUp"),
+        "nav:down": ("cursorDown", "selectDown"),
+        "flow:submit": ("submit", "selectConfirm"),
+        "flow:accept": ("tab",),
+        "flow:dismiss": ("selectCancel",),
+    }
+)