tumwater 0.4.0 → 0.4.2

package/dist/src/ui/transcript-tail.js

@@ -68,7 +68,20 @@ function markerHasLabel(line) {
  * readCompleteLines uses. A line straddling a chunk boundary is held (tail + newline) until
  * its head arrives from an older chunk, so no line is ever decoded torn. */
 export function readTranscriptTail(file, limit, opts = {}) {
-    const includePrompts = opts.includePrompts === true;
+    const opened = openTailFile(file);
+    if (opened === null)
+        return null;
+    try {
+        const state = scanTailFromEof(opened.fd, opened.size, limit, opts.includePrompts === true);
+        return finalizeTailWindow(file, state, limit, opts);
+    }
+    finally {
+        fs.closeSync(opened.fd);
+    }
+}
+/** Opens the log and stat-guards it: returns the opened `{ fd, size }`, or null when the file
+ * is missing, empty, or rotated away between stat and open. Owns the open/stat guard. */
+function openTailFile(file) {
     const st = statOrNull(file);
     if (!st || st.size === 0)
         return null;
@@ -88,130 +101,160 @@ export function readTranscriptTail(file, limit, opts = {}) {
         fs.closeSync(fd);
         return null;
     }
-    let pos = size; // Exclusive end of the not-yet-scanned region [pos - chunk, pos).
-    let held = EMPTY_BUFFER; // Tail (with its newline) of a line that starts before the current chunk and ends inside it.
-    const lines = []; // Complete lines, newest first.
-    let candidates = 0; // Entry-candidate lines seen so far, counting from EOF.
-    let end = 0; // Offset just past the last complete newline; 0 when the file has none.
-    let stoppedAtBoundary = false;
-    let armed = false; // A qualifying agent_start was recorded; walking older lines for its marker line.
-    let boundaryIndex = -1; // Index in `lines` of the arming agent_start (valid while armed).
+    return { fd, size };
+}
+/** Finds the newest complete line's start in a chunk and sets up the straddling-line hold at
+ * the chunk's outer boundary; returns the walk's emitStart, or null when the whole chunk is one
+ * incomplete line. Owns the chunk-boundary arithmetic. */
+function prepareTailChunk(fd, c, got, state) {
+    const lastNl = c.lastIndexOf(10);
+    if (lastNl < 0)
+        return null; // No complete line in this stretch yet.
+    if (state.end === 0)
+        state.end = state.pos - got + lastNl + 1; // The first complete line found is the newest one.
+    // The oldest line of c is incomplete when older bytes exist and the region does not
+    // start at a line boundary — hold it for the next chunk instead of decoding it torn.
+    let emitStart = 0;
+    if (state.pos - got > 0) {
+        const boundary = Buffer.alloc(1);
+        fs.readSync(fd, boundary, 0, 1, state.pos - got - 1);
+        if (boundary[0] !== 10) {
+            const firstNl = c.indexOf(10); // ≥ 0 — lastNl exists.
+            state.held = Buffer.from(c.subarray(0, firstNl + 1));
+            emitStart = firstNl + 1;
+        }
+    }
+    else {
+        state.held = EMPTY_BUFFER; // Reached file start: nothing older to hold for.
+    }
+    // A newline at c's start terminates a zero-length line (a blank line whose terminating
+    // \n is the region's first byte — e.g. the log starts with one). The walk below finds a
+    // line's start via lastIndexOf(10, lineEnd - 1), which for that line would search from
+    // index -1 and wrap to c's LAST newline — re-emitting every newer line until the
+    // candidate count reaches limit. Skip the zero-length line by starting the walk after it.
+    if (c[emitStart] === 10)
+        emitStart += 1;
+    return emitStart;
+}
+/** Advances the scan state across one pushed line: the arming walk while armed, else the
+ * candidate/agent_start transition; returns true when the walk must stop. Owns the arming
+ * state walk. */
+function advanceTailScan(raw, state, includePrompts, limit) {
     // Advances the arming state across one pushed line while `armed` — walking older lines for
     // the label-bearing marker that precedes the arming agent_start. Every line pushed here
     // sits inside [marker .. EOF] when a boundary lands, so the walk keeps it. Returns true when
     // a boundary was found and the walk must stop; false to keep walking.
-    const walkArmed = (raw) => {
+    const walkArmed = () => {
         if (raw.includes('"tumwater_run"')) {
             // A kind-only marker carries no label and is skipped — a full re-read lets it pass
             // through too — so the scan keeps walking to the labeled marker that actually applies,
             // or to the older agent_start when the run is unlabeled.
             if (markerHasLabel(raw)) {
-                armed = false; // Boundary found — the post-loop EOF-while-armed fallback must not fire.
-                stoppedAtBoundary = true; // Window [this marker .. EOF] renders identically to a full re-read.
+                state.armed = false; // Boundary found — the post-loop EOF-while-armed fallback must not fire.
+                state.stoppedAtBoundary = true; // Window [this marker .. EOF] renders identically to a full re-read.
                 return true;
             }
             return false;
         }
         if (raw.includes('"agent_start"')) {
-            lines.splice(boundaryIndex + 1); // No label before the next older run: unlabeled — stop at A.
-            armed = false;
-            stoppedAtBoundary = true;
+            state.lines.splice(state.boundaryIndex + 1); // No label before the next older run: unlabeled — stop at A.
+            state.armed = false;
+            state.stoppedAtBoundary = true;
             return true;
         }
         return false;
     };
-    try {
-        for (;;) {
-            const len = Math.min(TAIL_SCAN_CHUNK, pos);
-            if (len <= 0)
-                break;
-            const buf = Buffer.alloc(len);
-            const got = fs.readSync(fd, buf, 0, len, pos - len);
-            if (got <= 0)
-                break; // Shrank under us — use what we have.
-            // Covers the file region [pos - got, pos + held.length): this chunk plus the tail of
-            // the line that straddles its newer boundary (if any).
-            const c = held.length > 0 ? Buffer.concat([buf.subarray(0, got), held]) : buf.subarray(0, got);
-            const lastNl = c.lastIndexOf(10);
-            if (lastNl < 0) {
-                held = Buffer.from(c); // No complete line in this stretch yet.
-                pos -= got;
-                continue;
-            }
-            if (end === 0)
-                end = pos - got + lastNl + 1; // The first complete line found is the newest one.
-            // The oldest line of c is incomplete when older bytes exist and the region does not
-            // start at a line boundary — hold it for the next chunk instead of decoding it torn.
-            let emitStart = 0;
-            if (pos - got > 0) {
-                const boundary = Buffer.alloc(1);
-                fs.readSync(fd, boundary, 0, 1, pos - got - 1);
-                if (boundary[0] !== 10) {
-                    const firstNl = c.indexOf(10); // ≥ 0 — lastNl exists.
-                    held = Buffer.from(c.subarray(0, firstNl + 1));
-                    emitStart = firstNl + 1;
-                }
-            }
-            else {
-                held = EMPTY_BUFFER; // Reached file start: nothing older to hold for.
-            }
-            // A newline at c's start terminates a zero-length line (a blank line whose terminating
-            // \n is the region's first byte — e.g. the log starts with one). The walk below finds a
-            // line's start via lastIndexOf(10, lineEnd - 1), which for that line would search from
-            // index -1 and wrap to c's LAST newline — re-emitting every newer line until the
-            // candidate count reaches limit. Skip the zero-length line by starting the walk after it.
-            if (c[emitStart] === 10)
-                emitStart += 1;
-            let lineEnd = lastNl; // Byte index of the \n terminating the newest complete line in c.
-            while (lineEnd >= emitStart) {
-                const lineStart = c.lastIndexOf(10, lineEnd - 1) + 1;
-                if (lineStart < emitStart)
-                    break; // Safety — cannot happen: emitStart follows a \n.
-                const raw = c.toString("utf8", lineStart, lineEnd);
-                if (!raw.trim()) {
-                    lineEnd = lineStart - 1; // Blank lines render nothing.
-                    continue;
-                }
-                lines.push(raw);
-                if (armed) {
-                    // Walking for the label-bearing marker line preceding the arming agent_start.
-                    if (walkArmed(raw))
-                        break;
-                }
-                else if (isEntryCandidate(raw, includePrompts)) {
-                    candidates += 1;
-                }
-                else if (raw.includes('"agent_start"') && candidates >= limit) {
-                    armed = true; // Keep walking for the marker line preceding this agent_start.
-                    boundaryIndex = lines.length - 1;
-                }
-                lineEnd = lineStart - 1;
-            }
-            pos -= got;
-            if (stoppedAtBoundary || pos <= 0)
-                break;
+    if (state.armed)
+        return walkArmed();
+    if (isEntryCandidate(raw, includePrompts)) {
+        state.candidates += 1;
+        return false;
+    }
+    if (raw.includes('"agent_start"') && state.candidates >= limit) {
+        state.armed = true; // Keep walking for the marker line preceding this agent_start.
+        state.boundaryIndex = state.lines.length - 1;
+    }
+    return false;
+}
+/** Decodes and collects a chunk's complete lines newest-first, threading the arming state
+ * through advanceTailScan until the walk must stop. Owns the per-chunk line walk. */
+function walkTailChunkLines(state, c, emitStart, includePrompts, limit) {
+    let lineEnd = c.lastIndexOf(10); // Byte index of the \n terminating the newest complete line in c.
+    while (lineEnd >= emitStart) {
+        const lineStart = c.lastIndexOf(10, lineEnd - 1) + 1;
+        if (lineStart < emitStart)
+            break; // Safety — cannot happen: emitStart follows a \n.
+        const raw = c.toString("utf8", lineStart, lineEnd);
+        if (!raw.trim()) {
+            lineEnd = lineStart - 1; // Blank lines render nothing.
+            continue;
         }
+        state.lines.push(raw);
+        if (advanceTailScan(raw, state, includePrompts, limit))
+            break;
+        lineEnd = lineStart - 1;
     }
-    finally {
-        fs.closeSync(fd);
+}
+/** The backward chunk-scan loop over the opened fd, from EOF to file start, returning the
+ * threaded TailScanState. Owns the chunk scan loop. */
+function scanTailFromEof(fd, size, limit, includePrompts) {
+    const state = {
+        size,
+        pos: size, // Exclusive end of the not-yet-scanned region [pos - chunk, pos).
+        held: EMPTY_BUFFER, // Tail (with its newline) of a line that starts before the current chunk and ends inside it.
+        lines: [], // Complete lines, newest first.
+        candidates: 0, // Entry-candidate lines seen so far, counting from EOF.
+        end: 0, // Offset just past the last complete newline; 0 when the file has none.
+        stoppedAtBoundary: false,
+        armed: false, // A qualifying agent_start was recorded; walking older lines for its marker line.
+        boundaryIndex: -1, // Index in `lines` of the arming agent_start (valid while armed).
+    };
+    for (;;) {
+        const len = Math.min(TAIL_SCAN_CHUNK, state.pos);
+        if (len <= 0)
+            break;
+        const buf = Buffer.alloc(len);
+        const got = fs.readSync(fd, buf, 0, len, state.pos - len);
+        if (got <= 0)
+            break; // Shrank under us — use what we have.
+        // Covers the file region [pos - got, pos + held.length): this chunk plus the tail of
+        // the line that straddles its newer boundary (if any).
+        const c = state.held.length > 0
+            ? Buffer.concat([buf.subarray(0, got), state.held])
+            : buf.subarray(0, got);
+        const emitStart = prepareTailChunk(fd, c, got, state);
+        if (emitStart === null) {
+            state.held = Buffer.from(c); // No complete line in this stretch yet.
+            state.pos -= got;
+            continue;
+        }
+        walkTailChunkLines(state, c, emitStart, includePrompts, limit);
+        state.pos -= got;
+        if (state.stoppedAtBoundary || state.pos <= 0)
+            break;
     }
-    if (armed) {
+    return state;
+}
+/** Builds the rendered window from a finished (or EOF-armed) scan: the arming splice, the
+ * whole-file fallback and the slice(-limit) guard. Owns the final window. */
+function finalizeTailWindow(file, state, limit, opts) {
+    if (state.armed) {
         // Reached EOF while still arming: no marker precedes the run — unlabeled, stop at its
         // agent_start.
-        lines.splice(boundaryIndex + 1);
-        stoppedAtBoundary = true;
+        state.lines.splice(state.boundaryIndex + 1);
+        state.stoppedAtBoundary = true;
     }
-    let entries = formatTranscript(lines.reverse(), opts); // Oldest first.
-    if (entries.length < limit && stoppedAtBoundary) {
+    let entries = formatTranscript(state.lines.reverse(), opts); // Oldest first.
+    if (entries.length < limit && state.stoppedAtBoundary) {
         // Contentless assistant turns made the rendered entries fewer than the candidate count
         // promised — re-read the whole file (the pre-optimization behavior) so slice(-limit) is
         // exact.
-        entries = formatTranscript(readCompleteLines(file, 0, size).lines, opts);
+        entries = formatTranscript(readCompleteLines(file, 0, state.size).lines, opts);
     }
     // limit can be 0 (or negative — nonsense a caller should never pass): entries.slice(-0) is
     // entries.slice(0) — the whole window — because -0 === 0, so a bare slice(-limit) would
     // return everything instead of nothing; guard it, the same contract readTranscript's take
     // guard pins (the last `limit` entries of a zero-sized window is the empty list).
     const kept = limit > 0 ? entries.slice(-limit) : [];
-    return { entries: kept, end };
+    return { entries: kept, end: state.end };
 }

package/dist/src/ui/tui/tui-backlog.js

@@ -1,6 +1,6 @@
 import { answeredQuestionEntries, donePlanEntries, entryMatches, fixedBugEntries, openBugEntries, openQuestionEntries, plannedPlanEntries, } from "../../backlog/backlog.js";
 import { backlogHolds, backlogInProgress, backlogMarks, } from "../../backlog/backlog-eligibility.js";
-import { groupBlockedSeries, partsLabel } from "../../backlog/backlog-structure.js";
+import { groupBlockedSeries, partsLabel } from "../../backlog/backlog-index-data.js";
 import { clipToWidth } from "../../text/text-width.js";
 import { DASHBOARD_ANSWERED_QUESTIONS, DASHBOARD_RECENT_FINISHED } from "../status-payload.js";
 /** Pure project-status pane logic for the TUI (src/ui/tui/tui.tsx): the three-section backlog body

package/dist/src/ui/tui/tui-editor-answer.js

@@ -16,14 +16,13 @@ export function createAnswerEditor(session) {
         session.held.answer = null;
         restoreDraft();
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "a" &&
-            !session.anyEditorHeld() &&
+    // Ctrl+A opens the answer editor on the selected open question (mnemonic: **A**nswer);
+    // Enter records the decision through tryAnswerQuestion, the core `tumwater questions
+    // answer` and the dashboard's form share. The position is the question's 1-based index
+    // among the open questions: the browsable list puts plans, then bugs, then questions first.
+    const answerOpenEdit = (ctx) => {
+        if (!session.anyEditorHeld() &&
             ctx.view === ctx.roleIds.length + 1 && ctx.selectedEntry !== null) {
-            // Ctrl+A opens the answer editor on the selected open question (mnemonic: **A**nswer);
-            // Enter records the decision through tryAnswerQuestion, the core `tumwater questions
-            // answer` and the dashboard's form share. The position is the question's 1-based index
-            // among the open questions: the browsable list puts plans, then bugs, then questions first.
             try {
                 const entries = session.flat();
                 const sel = Math.min(ctx.selectedEntry, entries.length - 1);
@@ -46,47 +45,58 @@ export function createAnswerEditor(session) {
             }
             return true;
         }
-        if (key.name === "escape" && answerFor) {
-            // Esc cancels the answer editor, restoring the previous prompt text; nothing is written.
-            exitAnswerMode();
-            session.flashMessage("answer cancelled");
+        return false;
+    };
+    // Esc cancels the answer editor, restoring the previous prompt text; nothing is written.
+    const cancelAnswerEdit = () => {
+        exitAnswerMode();
+        session.flashMessage("answer cancelled");
+        return true;
+    };
+    // Enter records the answer through tryAnswerQuestion, titled so a question that moved
+    // since Ctrl+A is refused. A whitespace-only line, an unclosed fence, and a throw all
+    // flash and STAY in the editor so the text survives; answered and missing/moved both
+    // leave the editor and return the pane to list mode (the entry left the list).
+    const commitAnswerEdit = () => {
+        const target = answerFor;
+        if (target === null)
+            return false;
+        if (!session.input.trim()) {
+            session.flashMessage("questions answer needs a decision");
             return true;
         }
-        if (key.name === "return" && answerFor) {
-            // Enter records the answer through tryAnswerQuestion, titled so a question that moved
-            // since Ctrl+A is refused. A whitespace-only line, an unclosed fence, and a throw all
-            // flash and STAY in the editor so the text survives; answered and missing/moved both
-            // leave the editor and return the pane to list mode (the entry left the list).
-            const target = answerFor;
-            if (!session.input.trim()) {
-                session.flashMessage("questions answer needs a decision");
-                return true;
-            }
-            let outcome;
-            try {
-                outcome = tryAnswerQuestion(session.root, target.position, session.input, target.title);
-            }
-            catch (err) {
-                session.flashError(err);
-                return true;
-            }
-            if (outcome.status === "fenced") {
-                session.flashMessage(UNCLOSED_FENCE_MESSAGE);
-                return true;
-            }
-            let woke = "";
-            if (outcome.status === "answered") {
-                session.commitBacklogEdit("QUESTIONS.md", `Answer question: ${outcome.title}`);
-                if (wakeQuestionAsker(session.root, outcome.title) !== null)
-                    woke = ` · woke ${questionAsker(outcome.title)}`;
-            }
-            exitAnswerMode();
-            session.clearBacklogSelection();
-            session.flashMessage(outcome.status === "answered"
-                ? `answered question #${target.position}: ${outcome.title}${woke}`
-                : "that question was already answered or moved — nothing recorded");
+        let outcome;
+        try {
+            outcome = tryAnswerQuestion(session.root, target.position, session.input, target.title);
+        }
+        catch (err) {
+            session.flashError(err);
             return true;
         }
+        if (outcome.status === "fenced") {
+            session.flashMessage(UNCLOSED_FENCE_MESSAGE);
+            return true;
+        }
+        let woke = "";
+        if (outcome.status === "answered") {
+            session.commitBacklogEdit("QUESTIONS.md", `Answer question: ${outcome.title}`);
+            if (wakeQuestionAsker(session.root, outcome.title) !== null)
+                woke = ` · woke ${questionAsker(outcome.title)}`;
+        }
+        exitAnswerMode();
+        session.clearBacklogSelection();
+        session.flashMessage(outcome.status === "answered"
+            ? `answered question #${target.position}: ${outcome.title}${woke}`
+            : "that question was already answered or moved — nothing recorded");
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "a")
+            return answerOpenEdit(ctx);
+        if (key.name === "escape" && answerFor)
+            return cancelAnswerEdit();
+        if (key.name === "return" && answerFor)
+            return commitAnswerEdit();
         return false;
     };
     return { handleKey, exit: exitAnswerMode };

package/dist/src/ui/tui/tui-editor-attach.js

@@ -23,76 +23,87 @@ export function createAttachEditor(session) {
         session.held.attach = false;
         restoreDraft();
     };
-    const handleKey = (_str, key, ctx) => {
-        if (key.ctrl && key.name === "v" && ctx.view === 0) {
-            // Ctrl+V toggles image-attach mode on the Activity view's prompt line (mnemonic: attach
-            // **v**ia the same key the reset-counters and move-to-top arms use on their own views):
-            // the line edits one image path that rides into the next director prompt as the same
-            // `[image attached: …]` `tumwater prompt --attach <path>` and the dashboard composer
-            // write. Entering saves the director draft and blanks the line; leaving restores it.
-            if (session.editorEntryDenied("attach"))
-                return true;
-            if (attachMode) {
-                exitAttachMode();
-                session.flashMessage("image attach cancelled");
-            }
-            else {
-                // Mid-recall, hand the arrows' saved draft back before the attach editor takes the
-                // line — the same settle the role editors do — so leaving restores the
-                // draft, not a history entry, with no stale recall state riding along.
-                restoreDraft = session.takeDraft();
-                attachMode = true;
-                session.held.attach = true;
-                session.input = "";
-                session.cursor = 0;
-                session.flashMessage("attach an image path — Enter to attach, Esc to cancel");
-            }
+    // Ctrl+V toggles image-attach mode on the Activity view's prompt line (mnemonic: attach
+    // **v**ia the same key the reset-counters and move-to-top arms use on their own views):
+    // the line edits one image path that rides into the next director prompt as the same
+    // `[image attached: …]` `tumwater prompt --attach <path>` and the dashboard composer
+    // write. Entering saves the director draft and blanks the line; leaving restores it.
+    // Guarded to the Activity view (`ctx.view === 0`), so the Transcript reset arm, the
+    // Backlog move-to-top arm, and the Queued pane's move-to-top arm keep `Ctrl+V` on their
+    // views: a guard miss returns false and falls through the dispatch.
+    const toggleAttachEdit = (ctx) => {
+        if (ctx.view !== 0)
+            return false;
+        if (session.editorEntryDenied("attach"))
             return true;
+        if (attachMode) {
+            exitAttachMode();
+            session.flashMessage("image attach cancelled");
         }
-        if (key.name === "escape" && attachMode) {
-            // Esc cancels the attach editor, restoring the previous prompt text and leaving any
-            // already-saved pending images untouched.
+        else {
+            // Mid-recall, hand the arrows' saved draft back before the attach editor takes the
+            // line — the same settle the role editors do — so leaving restores the
+            // draft, not a history entry, with no stale recall state riding along.
+            restoreDraft = session.takeDraft();
+            attachMode = true;
+            session.held.attach = true;
+            session.input = "";
+            session.cursor = 0;
+            session.flashMessage("attach an image path — Enter to attach, Esc to cancel");
+        }
+        return true;
+    };
+    // Esc cancels the attach editor, restoring the previous prompt text and leaving any
+    // already-saved pending images untouched.
+    const cancelAttachEdit = () => {
+        exitAttachMode();
+        return true;
+    };
+    // Enter in attach mode reads the typed path as one image through the same rules
+    // `tumwater prompt --attach` uses (readPromptImageFiles), refuses a path no configured
+    // director seam can read up front, and stores it as a pending attachment on the session
+    // so the next director prompt carries it. Empty clears the pending images; a failed read
+    // or a refusal flashes and STAYS in the editor so the operator can fix the path. Either
+    // way the saved draft is restored.
+    const commitAttachEdit = () => {
+        const p = session.input.trim();
+        if (p === "") {
+            session.images = [];
             exitAttachMode();
+            session.flashMessage("image attach cleared");
             return true;
         }
-        if (key.name === "return" && attachMode) {
-            // Enter in attach mode reads the typed path as one image through the same rules
-            // `tumwater prompt --attach` uses (readPromptImageFiles), refuses a path no configured
-            // director seam can read up front, and stores it as a pending attachment on the session
-            // so the next director prompt carries it. Empty clears the pending images; a failed read
-            // or a refusal flashes and STAYS in the editor so the operator can fix the path. Either
-            // way the saved draft is restored.
-            const p = session.input.trim();
-            if (p === "") {
-                session.images = [];
-                exitAttachMode();
-                session.flashMessage("image attach cleared");
-                return true;
-            }
-            let readImages;
-            try {
-                readImages = readPromptImageFiles([p]);
-            }
-            catch (err) {
-                session.flashError(err);
-                return true;
-            }
-            const guidance = imagePromptGuidance(session.root, "director");
-            if (guidance.refusal) {
-                session.flashMessage(guidance.refusal);
-                return true;
-            }
-            const next = [...session.images, ...readImages];
-            const countProblem = promptImagesCountProblem(next.length);
-            if (countProblem !== null) {
-                session.flashMessage(countProblem);
-                return true;
-            }
-            session.images = next;
-            exitAttachMode();
-            session.flashMessage(guidance.notice ?? `attached ${path.basename(p)}`);
+        let readImages;
+        try {
+            readImages = readPromptImageFiles([p]);
+        }
+        catch (err) {
+            session.flashError(err);
             return true;
         }
+        const guidance = imagePromptGuidance(session.root, "director");
+        if (guidance.refusal) {
+            session.flashMessage(guidance.refusal);
+            return true;
+        }
+        const next = [...session.images, ...readImages];
+        const countProblem = promptImagesCountProblem(next.length);
+        if (countProblem !== null) {
+            session.flashMessage(countProblem);
+            return true;
+        }
+        session.images = next;
+        exitAttachMode();
+        session.flashMessage(guidance.notice ?? `attached ${path.basename(p)}`);
+        return true;
+    };
+    const handleKey = (_str, key, ctx) => {
+        if (key.ctrl && key.name === "v")
+            return toggleAttachEdit(ctx);
+        if (key.name === "escape" && attachMode)
+            return cancelAttachEdit();
+        if (key.name === "return" && attachMode)
+            return commitAttachEdit();
         return false;
     };
     return { handleKey, exit: exitAttachMode };