New-File Naming Dialog & Editor Filename Header Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Ask for a filename up front in a centered dialog whenever a new note is created, and show that filename in editor mode as an uneditable header bar styled like the preview's title bar.

Architecture: A new internal/dialog package holds the centered naming prompt as a self-contained Bubbletea sub-model (title, target-directory hint, textinput, Enter/Esc). App gains a ModeNamePrompt that owns one *dialog.Model reused for three jobs: new note, name-this-pathless-buffer, and F2 rename. The color helpers legibleText/relLuminance/hexToRGB move from internal/preview to internal/theme so the editor header and the preview title bar cannot drift. The header is painted into the existing three-row top pad, so it costs no text rows.

Tech Stack: Go 1.x, Bubbletea (github.com/charmbracelet/bubbletea), Bubbles (textinput), Lipgloss. Tests are stdlib testing, table-free, in-package (package app, package dialog).

Spec: docs/superpowers/specs/2026-07-30-new-file-dialog-design.md Backlog task: TASK-046

Global Constraints

• Module path is glint; internal imports are glint/internal/<pkg>.
• Every styled span gets an explicit color from theme.Theme — no terminal-default fallbacks (see internal/theme/theme.go package doc).
• paintCanvas must emit exactly height-1 rows; the status bar is the final row. Any change to the pad rows must preserve that invariant.
• New notes resolve through picker.NewNotePath(root, query), which trims the query, appends .md when the extension is not already .md, and returns "" for an empty query.
• File modes: directories 0o755, files 0o644.
• Tests live beside the code as <file>_test.go and use t.TempDir() for filesystem work.
• Run go test ./... before every commit. Run gofmt -l . and expect empty output.
• Commit messages: Conventional Commits, subject ≤ 50 chars, reference TASK-046 in the body.

File Structure

Created:

• internal/dialog/dialog.go — the centered naming prompt sub-model: state, key handling, view.
• internal/dialog/dialog_test.go — unit tests for the sub-model.
• internal/app/header.go — the editor filename header bar (render + text derivation).
• internal/app/header_test.go — header rendering tests.
• internal/app/naming.go — App-side glue: opening the dialog for new/rename, and the confirm handlers.
• internal/app/naming_test.go — new-file and rename flow tests.

Modified:

• internal/theme/theme.go — gains LegibleText, RelLuminance, HexToRGB.
• internal/theme/theme_test.go — tests for the moved helpers.
• internal/preview/preview.go — drops the local helpers, calls the theme ones.
• internal/preview/header.go — call sites updated to the theme helpers.
• internal/app/app.go — ModeNamePrompt replaces ModeSaveAs; saveInput/saveBar/promptSaveAs/saveAs removed; F2 key; newFile rerouted; paintCanvas paints the header.
• internal/app/app_test.go — the two ModeSaveAs assertions rewritten.
• internal/help/help.go — F2 documented, Ctrl+S wording updated.
• main.go — no change needed (StartNewIn handles the -n-with-no-name case internally); verified in Task 7.

Task 1: Move the color helpers into theme

legibleText, relLuminance, and hexToRGB currently live in internal/preview/preview.go (lines 127–160ish) and are used by internal/preview/header.go. The editor header needs the same math. Move them to theme, exported, and repoint preview.

Files:

• Modify: internal/theme/theme.go (append at end of file)
• Modify: internal/preview/preview.go:127-160 (delete the three funcs)
• Modify: internal/preview/header.go:63-64,111,114 (call sites)
• Test: internal/theme/theme_test.go (append)

Interfaces:

• Consumes: nothing.

• Produces:

  • func theme.HexToRGB(hex string) string — "#RRGGBB" → "R;G;B" decimal, "" when malformed.
  • func theme.RelLuminance(hex string) float64 — WCAG relative luminance, 0 when malformed.
  • func theme.LegibleText(bgHex string) string — "#100F0F" when the background is light (luminance > 0.5), else "#FFFCF0".

• Step 1: Write the failing test

Append to internal/theme/theme_test.go:

func TestHexToRGB(t *testing.T) {
	if got := HexToRGB("#FFFCF0"); got != "255;252;240" {
		t.Errorf("HexToRGB(#FFFCF0) = %q, want 255;252;240", got)
	}
	if got := HexToRGB("nope"); got != "" {
		t.Errorf("HexToRGB(nope) = %q, want empty", got)
	}
}

func TestLegibleTextPicksContrast(t *testing.T) {
	if got := LegibleText("#FFFCF0"); got != "#100F0F" {
		t.Errorf("LegibleText(light bg) = %q, want #100F0F", got)
	}
	if got := LegibleText("#100F0F"); got != "#FFFCF0" {
		t.Errorf("LegibleText(dark bg) = %q, want #FFFCF0", got)
	}
}

• Step 2: Run the test to verify it fails

Run: go test ./internal/theme/ -run 'TestHexToRGB|TestLegibleText' -v Expected: FAIL — undefined: HexToRGB, undefined: LegibleText.

• Step 3: Move the three functions into theme

Append to internal/theme/theme.go (and add "strconv" + "strings" to its import block):

// HexToRGB converts "#RRGGBB" to the "R;G;B" decimal form used in SGR codes.
// A malformed color yields "" so callers can fall back to unstyled output.
func HexToRGB(hex string) string {
	h := strings.TrimPrefix(hex, "#")
	if len(h) != 6 {
		return ""
	}
	r, err1 := strconv.ParseInt(h[0:2], 16, 0)
	g, err2 := strconv.ParseInt(h[2:4], 16, 0)
	b, err3 := strconv.ParseInt(h[4:6], 16, 0)
	if err1 != nil || err2 != nil || err3 != nil {
		return ""
	}
	return strconv.FormatInt(r, 10) + ";" + strconv.FormatInt(g, 10) + ";" + strconv.FormatInt(b, 10)
}

// LegibleText returns a near-black or near-paper text color, whichever
// contrasts better with the background hex, so heading text stays readable on
// any heading color.
func LegibleText(bgHex string) string {
	if RelLuminance(bgHex) > 0.5 {
		return "#100F0F"
	}
	return "#FFFCF0"
}

Then move relLuminance from internal/preview/preview.go verbatim, renaming it RelLuminance and exporting it, with this doc comment:

// RelLuminance is the WCAG relative luminance of an "#RRGGBB" color, 0 for a
// malformed one.
func RelLuminance(hex string) float64 {

Delete hexToRGB, legibleText, and relLuminance from internal/preview/preview.go, and drop strconv from that file's imports if nothing else there uses it (check with go build ./...).

• Step 4: Repoint the preview call sites

In internal/preview/header.go, add "glint/internal/theme" to the imports and replace the call sites:

• line ~63: if bg := hexToRGB(m.colors.Heading); bg != "" → if bg := theme.HexToRGB(m.colors.Heading); bg != ""
• line ~64: hexToRGB(legibleText(m.colors.Heading)) → theme.HexToRGB(theme.LegibleText(m.colors.Heading))
• line ~111: if c := hexToRGB(m.colors.Muted); c != "" → if c := theme.HexToRGB(m.colors.Muted); c != ""
• line ~114: if c := hexToRGB(m.colors.Text); c != "" → if c := theme.HexToRGB(m.colors.Text); c != ""

Search for any remaining lowercase call: grep -rn 'hexToRGB\|legibleText\|relLuminance' internal/ must return nothing.

• Step 5: Run the full suite

Run: go test ./... && gofmt -l . Expected: all packages PASS (preview's existing tests still pass — the rendered bytes are unchanged), gofmt -l . prints nothing.

• Step 6: Commit

git add internal/theme/theme.go internal/theme/theme_test.go internal/preview/preview.go internal/preview/header.go
git commit -m "refactor: move color helpers to theme package

HexToRGB/LegibleText/RelLuminance move out of internal/preview so the
editor filename header and the preview title bar derive identical colors
from one place (TASK-046)."

Task 2: The dialog package — state and key handling

A self-contained sub-model with no knowledge of App. It holds a title, a directory hint, a textinput, and an error line; Update returns a Result telling the caller what happened.

Files:

• Create: internal/dialog/dialog.go
• Test: internal/dialog/dialog_test.go

Interfaces:

• Consumes: theme.Theme (Task 1's package, unchanged fields).

• Produces:

  • type Model struct with unexported fields; constructed only via New.
  • func New(th theme.Theme) *Model
  • func (m *Model) Open(title, dirHint, prefill string) — resets the input, sets the prefill with the cursor at the end, clears any error, focuses.
  • func (m *Model) Title() string
  • func (m *Model) Value() string — the trimmed input text.
  • func (m *Model) SetError(msg string) — shows msg under the input and keeps the dialog open.
  • func (m *Model) SetTheme(th theme.Theme)
  • func (m *Model) SetWidth(w int) — the content-column width the box is sized against.
  • func (m *Model) Update(msg tea.Msg) (Result, tea.Cmd)
  • type Result int with ResultNone, ResultConfirm, ResultCancel.
  • func (m *Model) View() string (implemented in Task 3)

• Step 1: Write the failing test

Create internal/dialog/dialog_test.go:

package dialog

import (
	"testing"

	"glint/internal/theme"

	tea "github.com/charmbracelet/bubbletea"
)

func newModel() *Model { return New(theme.FlexokiDark()) }

func typeRunes(m *Model, s string) {
	for _, r := range s {
		m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
	}
}

func TestOpenSetsTitleAndPrefill(t *testing.T) {
	m := newModel()
	m.Open("Rename", "~/Notes/", "my-note")
	if m.Title() != "Rename" {
		t.Errorf("Title() = %q, want Rename", m.Title())
	}
	if m.Value() != "my-note" {
		t.Errorf("Value() = %q, want my-note", m.Value())
	}
}

func TestTypingAppendsAfterPrefill(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "draft")
	typeRunes(m, "-2")
	if m.Value() != "draft-2" {
		t.Errorf("Value() = %q, want draft-2 (cursor must start at end of prefill)", m.Value())
	}
}

func TestEnterConfirms(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "")
	typeRunes(m, "hello")
	res, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
	if res != ResultConfirm {
		t.Errorf("Enter gave %v, want ResultConfirm", res)
	}
	if m.Value() != "hello" {
		t.Errorf("Value() = %q, want hello", m.Value())
	}
}

func TestEscCancels(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "")
	res, _ := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
	if res != ResultCancel {
		t.Errorf("Esc gave %v, want ResultCancel", res)
	}
}

func TestOrdinaryKeysReturnNone(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "")
	res, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
	if res != ResultNone {
		t.Errorf("rune key gave %v, want ResultNone", res)
	}
}

func TestValueTrimsSurroundingSpace(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "")
	typeRunes(m, "  spaced  ")
	if m.Value() != "spaced" {
		t.Errorf("Value() = %q, want spaced", m.Value())
	}
}

func TestOpenClearsPreviousError(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "")
	m.SetError("Name taken")
	m.Open("New note", "~/Notes/", "")
	if m.err != "" {
		t.Errorf("err = %q after reopen, want empty", m.err)
	}
}

func TestTypingClearsError(t *testing.T) {
	m := newModel()
	m.Open("New note", "~/Notes/", "")
	m.SetError("Type a name first")
	typeRunes(m, "a")
	if m.err != "" {
		t.Errorf("err = %q after typing, want empty", m.err)
	}
}

• Step 2: Run the test to verify it fails

Run: go test ./internal/dialog/ -v Expected: FAIL — the package does not exist (no Go files in .../internal/dialog).

• Step 3: Write the implementation (state + keys only)

Create internal/dialog/dialog.go:

// Package dialog is glint's centered naming prompt: the modal box that asks for
// a filename when a note is created or renamed. It is a self-contained
// sub-model — it knows nothing about files, directories, or the app's modes,
// and only reports whether the user confirmed or cancelled.
package dialog

import (
	"strings"

	"glint/internal/theme"

	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
)

// Result is what a key press did to the dialog.
type Result int

const (
	ResultNone    Result = iota // still typing
	ResultConfirm               // Enter — the caller reads Value()
	ResultCancel                // Esc — the caller restores the previous mode
)

// Model is the naming prompt.
type Model struct {
	th      theme.Theme
	input   textinput.Model
	title   string // "New note" / "Rename"
	dirHint string // the folder the name resolves under, shown under the title
	err     string // validation message shown under the input
	width   int    // content-column width the box is sized against
}

// New builds an empty dialog. Open puts it into a usable state.
func New(th theme.Theme) *Model {
	ti := textinput.New()
	ti.Prompt = "› "
	ti.Placeholder = "name…"
	return &Model{th: th, input: ti}
}

// Open resets the dialog for one use: title above, dirHint under it, prefill in
// the input with the cursor at the end, no error.
func (m *Model) Open(title, dirHint, prefill string) {
	m.title = title
	m.dirHint = dirHint
	m.err = ""
	m.input.SetValue(prefill)
	m.input.CursorEnd()
	m.input.Focus()
}

// Title is the dialog's heading.
func (m *Model) Title() string { return m.title }

// Value is the typed name with surrounding whitespace trimmed.
func (m *Model) Value() string { return strings.TrimSpace(m.input.Value()) }

// SetError shows msg under the input; the dialog stays open. Typing clears it.
func (m *Model) SetError(msg string) { m.err = msg }

// SetTheme repaints the dialog after a theme cycle.
func (m *Model) SetTheme(th theme.Theme) { m.th = th }

// SetWidth sets the content-column width the box is sized against.
func (m *Model) SetWidth(w int) { m.width = w }

// Update handles one message. Enter confirms, Esc cancels, everything else
// edits the input (and clears a stale validation message).
func (m *Model) Update(msg tea.Msg) (Result, tea.Cmd) {
	if k, ok := msg.(tea.KeyMsg); ok {
		switch k.Type {
		case tea.KeyEnter:
			return ResultConfirm, nil
		case tea.KeyEsc:
			return ResultCancel, nil
		}
	}
	m.err = ""
	var cmd tea.Cmd
	m.input, cmd = m.input.Update(msg)
	return ResultNone, cmd
}

• Step 4: Run the test to verify it passes

Run: go test ./internal/dialog/ -v Expected: PASS (8 tests). View is not exercised yet.

• Step 5: Commit

git add internal/dialog/
git commit -m "feat: naming dialog sub-model (state + keys)

Centered filename prompt as a self-contained Bubbletea sub-model:
Open/Value/SetError plus Enter-confirms, Esc-cancels (TASK-046)."

Task 3: The dialog view

The box: rounded border in theme.Heading, themed background, title, dir hint, input, footer, and the error line when set. Same visual family as App.helpOverlay (internal/app/app.go:1021).

Files:

• Modify: internal/dialog/dialog.go (append View)
• Test: internal/dialog/dialog_test.go (append)

Interfaces:

• Consumes: Model from Task 2.

• Produces: func (m *Model) View() string — the fully rendered box, no trailing newline.

• Step 1: Write the failing test

Append to internal/dialog/dialog_test.go:

import "github.com/charmbracelet/lipgloss" // add to the existing import block

func TestViewShowsTitleDirAndFooter(t *testing.T) {
	m := newModel()
	m.SetWidth(60)
	m.Open("New note", "~/Humdrum/Inbox/", "")
	out := m.View()
	for _, want := range []string{"New note", "~/Humdrum/Inbox/", "Enter", "Esc"} {
		if !strings.Contains(out, want) {
			t.Errorf("View() missing %q:\n%s", want, out)
		}
	}
}

func TestViewShowsErrorWhenSet(t *testing.T) {
	m := newModel()
	m.SetWidth(60)
	m.Open("New note", "~/Notes/", "")
	if strings.Contains(m.View(), "Name taken") {
		t.Fatal("View() shows the error before SetError")
	}
	m.SetError("Name taken")
	if !strings.Contains(m.View(), "Name taken") {
		t.Errorf("View() missing the error line:\n%s", m.View())
	}
}

func TestViewFitsContentWidth(t *testing.T) {
	m := newModel()
	m.SetWidth(40)
	m.Open("New note", "~/Notes/", "")
	for i, ln := range strings.Split(m.View(), "\n") {
		if w := lipgloss.Width(ln); w > 40 {
			t.Errorf("line %d width = %d, want <= 40", i, w)
		}
	}
}

Add "strings" to the test file's imports.

• Step 2: Run the test to verify it fails

Run: go test ./internal/dialog/ -run TestView -v Expected: FAIL — m.View undefined (type *Model has no field or method View).

• Step 3: Write the implementation

Append to internal/dialog/dialog.go (add "github.com/charmbracelet/lipgloss" to the imports):

// boxMin is the narrowest the dialog box gets before it just takes the column.
const boxMin = 24

// View renders the dialog as a centered bordered box: title, the folder the
// name lands in, the input, an optional validation line, then the key footer.
func (m *Model) View() string {
	inner := lipgloss.NewStyle().Foreground(m.th.Heading).Bold(true).Render(m.title)
	if m.dirHint != "" {
		inner += "\n" + lipgloss.NewStyle().Foreground(m.th.Muted).Render("in "+m.dirHint)
	}
	inner += "\n\n" + m.input.View()
	if m.err != "" {
		inner += "\n\n" + lipgloss.NewStyle().Foreground(m.th.Spell).Render(m.err)
	}
	inner += "\n\n" + lipgloss.NewStyle().Foreground(m.th.Muted).
		Render("Enter to confirm · Esc to cancel")

	w := m.width - 2 // the border takes one cell each side
	if w < boxMin {
		w = boxMin
	}
	box := lipgloss.NewStyle().
		Border(lipgloss.RoundedBorder()).
		BorderForeground(m.th.Heading).
		BorderBackground(m.th.Background).
		Background(m.th.Background).
		Foreground(m.th.Text).
		Padding(0, 1).
		Width(w)
	return box.Render(inner)
}

Note on width: Padding(0, 1) sits inside Width(w), so the rendered box is w + 2 cells wide including the border. TestViewFitsContentWidth sets width 40 → w = 38 → 40 rendered. Keep that arithmetic; if the test fails by exactly 2 cells, the padding/width interaction changed and w needs m.width - 2 re-derived, not the test relaxed.

• Step 4: Run the test to verify it passes

Run: go test ./internal/dialog/ -v Expected: PASS (11 tests).

• Step 5: Commit

git add internal/dialog/
git commit -m "feat: naming dialog view (centered bordered box)

Title, target-folder hint, input, validation line, and key footer in the
same visual family as the help overlay (TASK-046)."

Task 4: The editor filename header

The bar text and its rendering, independent of the dialog. It goes into the existing top pad, so paintCanvas gains a header row rather than an extra one.

Files:

• Create: internal/app/header.go
• Modify: internal/app/app.go:1070-1090 (paintCanvas)
• Test: internal/app/header_test.go

Interfaces:

• Consumes: theme.LegibleText (Task 1), App.path, App.editor.Dirty, App.contentWidth(), App.theme.
• Produces:
  • func (a *App) headerText() string — basename minus .md, plus " •" when dirty; "Untitled" (plus the dirty bullet) for a pathless buffer.
  • func (a *App) headerBar() string — one rendered row, content-column wide; "" when the header should not show.
  • func (a *App) showHeader() bool — true in ModeEditor, ModeFind, ModeGotoLine, ModeSpell, ModeNamePrompt; false otherwise.

ModeNamePrompt does not exist until Task 5. Until then showHeader lists only the four existing modes; Task 5 adds the fifth. This is called out again in Task 5, Step 4.

• Step 1: Write the failing test

Create internal/app/header_test.go:

package app

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	"glint/internal/theme"

	tea "github.com/charmbracelet/bubbletea"
)

func TestHeaderTextIsBasenameWithoutExtension(t *testing.T) {
	a := newApp()
	a.path = "/tmp/notes/my-note.md"
	if got := a.headerText(); got != "my-note" {
		t.Errorf("headerText() = %q, want my-note", got)
	}
}

func TestHeaderTextMarksDirty(t *testing.T) {
	a := newApp()
	a.path = "/tmp/notes/my-note.md"
	a.editor.Dirty = true
	if got := a.headerText(); got != "my-note •" {
		t.Errorf("headerText() = %q, want 'my-note •'", got)
	}
}

func TestHeaderTextForPathlessBuffer(t *testing.T) {
	a := newApp()
	a.path = ""
	if got := a.headerText(); got != "Untitled" {
		t.Errorf("headerText() = %q, want Untitled", got)
	}
}

func TestHeaderIgnoresFrontmatterTitle(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "on-disk.md")
	os.WriteFile(p, []byte("---\ntitle: Something Else\n---\n\nbody"), 0o644)

	a := newApp()
	if err := a.Load(p); err != nil {
		t.Fatal(err)
	}
	if got := a.headerText(); got != "on-disk" {
		t.Errorf("headerText() = %q, want on-disk (edit mode shows the file, not the title)", got)
	}
}

func TestHeaderBarAppearsInEditorView(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "visible.md")
	os.WriteFile(p, []byte("body"), 0o644)

	a := newApp()
	a.theme = theme.FlexokiDark()
	a.editor.SetTheme(theme.FlexokiDark())
	a.Load(p)
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 12})
	if !strings.Contains(a.View(), "visible") {
		t.Errorf("editor View() has no filename header:\n%s", a.View())
	}
}

func TestHeaderCostsNoTextRows(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "rows.md")
	os.WriteFile(p, []byte("body"), 0o644)

	a := newApp()
	a.Load(p)
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	gotW, gotH := a.editor.Size()
	if gotH != 20-1-canvasTopPad {
		t.Errorf("editor height = %d, want %d (header must not steal a text row)", gotH, 20-1-canvasTopPad)
	}
	if gotW != a.contentWidth() {
		t.Errorf("editor width = %d, want %d", gotW, a.contentWidth())
	}
}

func TestViewIsExactlyHeightRows(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "rows2.md")
	os.WriteFile(p, []byte("body"), 0o644)

	a := newApp()
	a.Load(p)
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 14})
	if n := len(strings.Split(a.View(), "\n")); n != 14 {
		t.Errorf("View() = %d lines, want 14 (canvas height-1 + status bar)", n)
	}
}

func TestHeaderHiddenInPicker(t *testing.T) {
	a := newApp()
	a.path = "/tmp/notes/hidden.md"
	a.mode = ModePicker
	if a.showHeader() {
		t.Error("showHeader() = true in ModePicker, want false")
	}
}

func TestHeaderHiddenInPreviewAndHelp(t *testing.T) {
	a := newApp()
	a.path = "/tmp/notes/hidden.md"
	for _, m := range []Mode{ModePreview, ModeHelp} {
		a.mode = m
		if a.showHeader() {
			t.Errorf("showHeader() = true in mode %d, want false", m)
		}
	}
}

func TestHeaderShownInOverlayModes(t *testing.T) {
	a := newApp()
	a.path = "/tmp/notes/shown.md"
	for _, m := range []Mode{ModeEditor, ModeFind, ModeGotoLine, ModeSpell} {
		a.mode = m
		if !a.showHeader() {
			t.Errorf("showHeader() = false in mode %d, want true", m)
		}
	}
}

If editor.Editor has no Size() accessor, replace the TestHeaderCostsNoTextRows body's first line with a direct read of whatever the editor exposes — check with grep -n 'func (e \*Editor) Size\|width\|height' internal/editor/editor.go first, and if there is no accessor, add one:

// Size returns the editor's current viewport width and height in cells.
func (e *Editor) Size() (int, int) { return e.width, e.height }

(placed next to SetSize in internal/editor/editor.go, using that struct's actual field names).

• Step 2: Run the test to verify it fails

Run: go test ./internal/app/ -run TestHeader -v Expected: FAIL — a.headerText undefined, a.showHeader undefined.

• Step 3: Write the implementation

Create internal/app/header.go:

package app

import (
	"path/filepath"
	"strings"

	"glint/internal/theme"

	"github.com/charmbracelet/lipgloss"
)

// headerText is the name shown in the editor's filename bar: the file's
// basename without its extension, or "Untitled" for a buffer with no path. A
// frontmatter "title" deliberately does not override it — edit mode shows what
// is on disk. Unsaved changes append a bullet.
func (a *App) headerText() string {
	name := "Untitled"
	if a.path != "" {
		base := filepath.Base(a.path)
		name = strings.TrimSuffix(base, filepath.Ext(base))
	}
	if a.editor.Dirty {
		name += " •"
	}
	return name
}

// showHeader reports whether the filename bar belongs on screen: in the editor
// and the overlays that keep it visible beneath them. The picker has its own
// layout, help replaces the body, and preview draws its own title bar.
func (a *App) showHeader() bool {
	switch a.mode {
	case ModeEditor, ModeFind, ModeGotoLine, ModeSpell:
		return true
	}
	return false
}

// headerBar renders the filename as one content-column-wide row: a bold filled
// block in the heading color for a named file, muted plain text for an unnamed
// buffer so "unsaved and unnamed" reads at a glance. Returns "" when the header
// does not belong on screen.
func (a *App) headerBar() string {
	if !a.showHeader() {
		return ""
	}
	w := a.contentWidth()
	if w < 3 {
		return ""
	}
	label := truncate(" "+a.headerText()+" ", w)
	if a.path == "" {
		return lipgloss.NewStyle().
			Foreground(a.theme.Muted).
			Background(a.theme.Background).
			Width(w).
			Render(label)
	}
	return lipgloss.NewStyle().
		Bold(true).
		Foreground(lipgloss.Color(theme.LegibleText(string(a.theme.Heading)))).
		Background(a.theme.Heading).
		Width(w).
		Render(label)
}

Then modify paintCanvas in internal/app/app.go — replace the pad loop:

	for p := 0; p < a.topPad(); p++ {
		rows = append(rows, bg.Render(""))
	}

with:

	// The filename bar lives in the middle row of the top pad, so it costs no
	// text rows: the canvas is still exactly height-1 rows.
	header := a.headerBar()
	for p := 0; p < a.topPad(); p++ {
		if p == 1 && header != "" {
			rows = append(rows, bg.Render(lm+header))
			continue
		}
		rows = append(rows, bg.Render(""))
	}

• Step 4: Run the tests to verify they pass

Run: go test ./internal/app/ -v Expected: PASS, including the pre-existing TestCanvasPaintsFullWidthBackground (the header row is background-filled to the terminal width like every other row).

• Step 5: Commit

git add internal/app/header.go internal/app/header_test.go internal/app/app.go
git commit -m "feat: filename header bar in editor mode

Basename (minus .md) as a heading-colored bar painted into the existing
top pad, so it costs no text rows. Pathless buffers show a muted
'Untitled'; a dirty buffer appends a bullet (TASK-046)."

Task 5: Wire ModeNamePrompt into App

Swap ModeSaveAs for ModeNamePrompt, hold the dialog on App, and route keys. The confirm handlers land in Task 6 — this task ends with a dialog that opens, types, and cancels, with confirm as a stub that only closes.

Files:

• Modify: internal/app/app.go (mode consts, struct, New, handleKey, View, setSize, cycleTheme)
• Create: internal/app/naming.go
• Test: internal/app/naming_test.go

Interfaces:

• Consumes: dialog.New/Open/Update/View/SetTheme/SetWidth/Value/SetError, Result* (Tasks 2–3); a.showHeader (Task 4).

• Produces:

  • ModeNamePrompt Mode — replaces ModeSaveAs in the const block.
  • App.dialog *dialog.Model, App.dialogKind namingKind, App.dialogDir string, App.prevMode Mode.
  • type namingKind int with namingNew, namingRename.
  • func (a *App) openNamePrompt(kind namingKind, dir, prefill string) — sets prevMode, dialogKind, dialogDir, opens the dialog, switches mode.
  • func (a *App) handleNameKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) — routes into the dialog and dispatches on Result.
  • func (a *App) confirmName() (tea.Model, tea.Cmd) — stubbed here, implemented in Task 6.
  • func (a *App) cancelName() (tea.Model, tea.Cmd) — restores prevMode, clears status.
  • func (a *App) dirLabel(dir string) string — dir with $HOME replaced by ~, trailing separator added.

• Step 1: Write the failing test

Create internal/app/naming_test.go:

package app

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	tea "github.com/charmbracelet/bubbletea"
)

func typeInto(a *App, s string) {
	for _, r := range s {
		a.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
	}
}

func TestCtrlNOpensNamePrompt(t *testing.T) {
	a := newApp()
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	a.Update(tea.KeyMsg{Type: tea.KeyCtrlN})
	if a.mode != ModeNamePrompt {
		t.Fatalf("mode = %d, want ModeNamePrompt", a.mode)
	}
	if a.dialog.Title() != "New note" {
		t.Errorf("dialog title = %q, want 'New note'", a.dialog.Title())
	}
}

func TestNamePromptShowsTargetDir(t *testing.T) {
	dir := t.TempDir()
	a := newApp()
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	a.openNamePrompt(namingNew, dir, "")
	if !strings.Contains(a.View(), filepath.Base(dir)) {
		t.Errorf("View() does not show the target dir %q:\n%s", dir, a.View())
	}
}

func TestEscCancelsBackToPreviousMode(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "open.md")
	os.WriteFile(p, []byte("body"), 0o644)

	a := newApp()
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	a.Load(p)
	a.Update(tea.KeyMsg{Type: tea.KeyCtrlN})
	a.Update(tea.KeyMsg{Type: tea.KeyEsc})
	if a.mode != ModeEditor {
		t.Errorf("mode = %d after Esc, want ModeEditor", a.mode)
	}
	if a.path != p {
		t.Errorf("path = %q after Esc, want the file we were editing (%q)", a.path, p)
	}
	entries, _ := os.ReadDir(dir)
	if len(entries) != 1 {
		t.Errorf("Esc wrote %d entries to disk, want 1 (the pre-existing file)", len(entries))
	}
}

func TestDirtyBufferConfirmsDiscardBeforePrompt(t *testing.T) {
	a := newApp()
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	a.editor.SetContent([]byte("x"))
	a.editor.Dirty = true
	a.Update(tea.KeyMsg{Type: tea.KeyCtrlN})
	if a.mode == ModeNamePrompt {
		t.Fatal("first Ctrl+N on a dirty buffer opened the prompt; want a discard confirmation")
	}
	a.Update(tea.KeyMsg{Type: tea.KeyCtrlN})
	if a.mode != ModeNamePrompt {
		t.Errorf("second Ctrl+N: mode = %d, want ModeNamePrompt", a.mode)
	}
}

func TestPickerCtrlNPrefillsQuery(t *testing.T) {
	dir := t.TempDir()
	a := newApp()
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	if err := a.StartPickerIn(dir); err != nil {
		t.Fatal(err)
	}
	typeInto(a, "draft")
	a.Update(tea.KeyMsg{Type: tea.KeyCtrlN})
	if a.mode != ModeNamePrompt {
		t.Fatalf("mode = %d, want ModeNamePrompt", a.mode)
	}
	if a.dialog.Value() != "draft" {
		t.Errorf("dialog prefill = %q, want draft", a.dialog.Value())
	}
}

func TestF2OpensRenamePrefilled(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "before.md")
	os.WriteFile(p, []byte("body"), 0o644)

	a := newApp()
	a.Update(tea.WindowSizeMsg{Width: 100, Height: 20})
	a.Load(p)
	a.Update(tea.KeyMsg{Type: tea.KeyF2})
	if a.mode != ModeNamePrompt {
		t.Fatalf("mode = %d, want ModeNamePrompt", a.mode)
	}
	if a.dialog.Title() != "Rename" {
		t.Errorf("dialog title = %q, want Rename", a.dialog.Title())
	}
	if a.dialog.Value() != "before" {
		t.Errorf("dialog prefill = %q, want before", a.dialog.Value())
	}
}

• Step 2: Run the test to verify it fails

Run: go test ./internal/app/ -run 'TestCtrlNOpens|TestNamePrompt|TestEscCancels|TestDirty|TestPickerCtrlN|TestF2' -v Expected: FAIL — undefined: ModeNamePrompt, a.dialog undefined, undefined: namingNew.

• Step 3: Edit app.go — modes, struct, constructor

In the mode const block (internal/app/app.go:34-42), replace ModeSaveAs with ModeNamePrompt:

const (
	ModeEditor Mode = iota
	ModePicker
	ModePreview
	ModeNamePrompt // centered dialog naming a new or renamed file (TASK-046)
	ModeFind
	ModeHelp
	ModeGotoLine
	ModeSpell
)

In the App struct: delete the saveInput textinput.Model field and add, next to picker:

	dialog     *dialog.Model // centered new-file / rename prompt (TASK-046)
	dialogKind namingKind    // what the open dialog will do on confirm
	dialogDir  string        // directory a new name resolves under
	prevMode   Mode          // mode to restore when the dialog is cancelled

Keep saveDir — startBlankIn still sets it and Task 6's confirm reads it as the fallback directory.

In New (internal/app/app.go:96-134): delete the ti := textinput.New(); ti.Prompt = "save as › "; ti.Placeholder = "name…" block and the saveInput: ti, field, then after a.preview = preview.New(...) add:

	a.dialog = dialog.New(th)

Add "glint/internal/dialog" to the imports. If textinput is still used by findInput/gotoInput (it is), leave that import alone.

• Step 4: Edit app.go — key routing, view, sizing, theme; extend showHeader

handleKey, in the switch msg.Type block, add after case tea.KeyCtrlL::

	case tea.KeyF2:
		return a.renameFile()

In the same function's case tea.KeyEsc: arm, the current body forces a.mode = ModeEditor. The dialog must cancel to prevMode instead — add this guard as the first statement of the KeyEsc arm:

		if a.mode == ModeNamePrompt {
			return a.cancelName()
		}

In the trailing switch a.mode block, replace the whole case ModeSaveAs: arm with:

	case ModeNamePrompt:
		return a.handleNameKey(msg)

In View() (internal/app/app.go:987), the switch a.mode that picks body gains an arm before default::

	case ModeNamePrompt:
		body = a.dialog.View()

and the second switch a.mode that picks bottom loses its case ModeSaveAs: bottom = a.saveBar() arm entirely (the dialog carries its own footer; the status bar stays).

Delete saveBar() (internal/app/app.go:1056-1063), promptSaveAs() (:564-570), and saveAs() (:574-598).

In save() (internal/app/app.go:468), replace the two save-as references. The current head is:

func (a *App) save() (tea.Model, tea.Cmd) {
	if a.mode == ModeSaveAs {
		return a.saveAs() // Ctrl+S confirms an open save-as prompt

Read the rest of save() and replace that guard with:

func (a *App) save() (tea.Model, tea.Cmd) {
	if a.mode == ModeNamePrompt {
		return a.confirmName() // Ctrl+S confirms an open naming prompt
	}

and replace the later return a.promptSaveAs() (the pathless-buffer branch) with:

		return a.nameCurrentBuffer()

In setSize (internal/app/app.go:915), after a.preview.SetSize(cw, textRows) add:

	a.dialog.SetWidth(cw)

In cycleTheme (internal/app/app.go:838), wherever it repaints the editor/preview/picker, add:

	a.dialog.SetTheme(a.theme)

In internal/app/header.go, extend showHeader to keep the header visible behind the dialog:

	case ModeEditor, ModeFind, ModeGotoLine, ModeSpell, ModeNamePrompt:
		return true

Wait — the dialog replaces body in View, so the editor is not visible beneath it, but the header lives in the pad and still reads correctly as "this is the file you were in". Keep it shown. Add a matching case to TestHeaderShownInOverlayModes in internal/app/header_test.go:

	for _, m := range []Mode{ModeEditor, ModeFind, ModeGotoLine, ModeSpell, ModeNamePrompt} {

• Step 5: Write naming.go (open/cancel, confirm stubbed)

Create internal/app/naming.go:

package app

import (
	"os"
	"path/filepath"
	"strings"

	"glint/internal/dialog"

	tea "github.com/charmbracelet/bubbletea"
)

// namingKind is what an open naming dialog will do when confirmed.
type namingKind int

const (
	namingNew    namingKind = iota // create dialogDir/<name>.md and open it
	namingRename                   // rename the current file to <name>.md
)

// openNamePrompt shows the centered naming dialog. dir is the folder a new name
// resolves under; prefill seeds the input (the picker query, or the current
// basename for a rename). Cancelling returns to whatever mode was active.
func (a *App) openNamePrompt(kind namingKind, dir, prefill string) {
	title := "New note"
	if kind == namingRename {
		title = "Rename"
	}
	a.prevMode = a.mode
	a.dialogKind = kind
	a.dialogDir = dir
	a.dialog.SetWidth(a.contentWidth())
	a.dialog.Open(title, a.dirLabel(dir), prefill)
	a.mode = ModeNamePrompt
	a.status = ""
}

// renameFile is the F2 handler: rename the open file, or name a buffer that has
// no path yet. Only meaningful over the editor.
func (a *App) renameFile() (tea.Model, tea.Cmd) {
	if a.mode == ModePicker || a.mode == ModeNamePrompt {
		return a, nil
	}
	if a.path == "" {
		return a.nameCurrentBuffer()
	}
	base := filepath.Base(a.path)
	a.openNamePrompt(namingRename, filepath.Dir(a.path), strings.TrimSuffix(base, filepath.Ext(base)))
	return a, nil
}

// nameCurrentBuffer names a pathless buffer, then writes it — the job the
// bottom-bar save-as prompt used to do.
func (a *App) nameCurrentBuffer() (tea.Model, tea.Cmd) {
	dir := a.saveDir
	if dir == "" {
		dir = a.cfg.InboxRoot()
	}
	a.openNamePrompt(namingRename, dir, "")
	return a, nil
}

// handleNameKey routes a key into the dialog and acts on what it reports.
func (a *App) handleNameKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
	res, cmd := a.dialog.Update(msg)
	switch res {
	case dialog.ResultConfirm:
		return a.confirmName()
	case dialog.ResultCancel:
		return a.cancelName()
	}
	return a, cmd
}

// cancelName closes the dialog and restores the mode it opened over, writing
// nothing.
func (a *App) cancelName() (tea.Model, tea.Cmd) {
	a.mode = a.prevMode
	a.status = ""
	return a, nil
}

// dirLabel renders dir for the dialog's hint: $HOME collapsed to ~, one
// trailing separator so it reads as a folder.
func (a *App) dirLabel(dir string) string {
	if home, err := os.UserHomeDir(); err == nil && home != "" && strings.HasPrefix(dir, home) {
		dir = "~" + strings.TrimPrefix(dir, home)
	}
	return strings.TrimSuffix(dir, string(filepath.Separator)) + string(filepath.Separator)
}

// confirmName applies the dialog's name. Implemented in the next task.
func (a *App) confirmName() (tea.Model, tea.Cmd) {
	return a.cancelName()
}