gui: conditions as a nested tree, and a way to add a directory

10 files changed, 590 insertions, 32 deletions

diff --git a/docs/gui-checklist.md b/docs/gui-checklist.md
index 5a7d08a..3eaeb60 100644
--- a/docs/gui-checklist.md
+++ b/docs/gui-checklist.md
@@ -141,3 +141,8 @@ A dialog is its own window: take it by its own id, not the main window's.
 46. "Keep this copy, replace the other" appears only for a file with
     another copy, asks first, naming both, and after Apply the kept file is
     in the other's place with the other in the Trash.
+47. Add directory writes dirs/NAME.conf and adds the name to the include;
+    both pickers then offer it, and krino check sees it.
+48. A rule's conditions are a tree: and / or / not hold the conditions
+    indented under them, "+" adds a test or an operator under a line, "-"
+    takes one out, and saving writes the same nesting back.
diff --git a/gui/internal/model/cond.go b/gui/internal/model/cond.go
new file mode 100644
index 0000000..04cc4d1
--- /dev/null
+++ b/gui/internal/model/cond.go
@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package model
+
+import (
+	"fmt"
+	"strings"
+
+	"krino/internal/sexp"
+)
+
+// CondOps are the forms that hold other conditions.
+var CondOps = map[string]bool{"and": true, "or": true, "not": true}
+
+// CondTests are the tests a condition can make, in the order a picker
+// offers them.
+var CondTests = []string{"type", "name", "path", "content", "size", "age", "duplicate", "matched"}
+
+// Cond is one condition in the tree the forms editor shows: either a test,
+// with its arguments as the file writes them, or one of and / or / not
+// holding the conditions under it (GUI design §5.1).
+type Cond struct {
+	Kind     string
+	Args     string
+	Children []*Cond
+}
+
+// ParseCond reads a parsed form into the tree. Anything that is not a list
+// - which the config parser refuses anyway - comes back as a test with the
+// text as its arguments, so nothing is ever silently dropped.
+func ParseCond(n *sexp.Node) *Cond {
+	if n == nil {
+		return &Cond{Kind: "type"}
+	}
+	if n.Kind != sexp.List || len(n.Children) == 0 {
+		return &Cond{Kind: n.String()}
+	}
+	head := n.Head()
+	if CondOps[head] {
+		c := &Cond{Kind: head}
+		for _, child := range n.Args() {
+			c.Children = append(c.Children, ParseCond(child))
+		}
+		return c
+	}
+	var args []string
+	for _, a := range n.Args() {
+		args = append(args, a.String())
+	}
+	return &Cond{Kind: head, Args: strings.Join(args, " ")}
+}
+
+// Text writes the condition back as krino reads it.
+func (c *Cond) Text() string {
+	if c == nil {
+		return ""
+	}
+	if CondOps[c.Kind] {
+		parts := make([]string, 0, len(c.Children))
+		for _, child := range c.Children {
+			if t := child.Text(); t != "" {
+				parts = append(parts, t)
+			}
+		}
+		if len(parts) == 0 {
+			return ""
+		}
+		return "(" + c.Kind + " " + strings.Join(parts, " ") + ")"
+	}
+	args := strings.TrimSpace(c.Args)
+	if args == "" {
+		return "(" + c.Kind + ")"
+	}
+	return "(" + c.Kind + " " + args + ")"
+}
+
+// Parse checks that a condition is one krino can read, and says where it is
+// wrong if it is not.
+func (c *Cond) Parse() error {
+	text := c.Text()
+	if text == "" {
+		return fmt.Errorf("%s has nothing under it", c.Kind)
+	}
+	nodes, err := sexp.Parse("form", []byte(text))
+	if err != nil {
+		return err
+	}
+	if len(nodes) != 1 {
+		return fmt.Errorf("%s is not one condition", text)
+	}
+	return nil
+}
+
+// Add puts a new condition under an operator; a test gets none.
+func (c *Cond) Add(kind string) *Cond {
+	if !CondOps[c.Kind] {
+		return nil
+	}
+	child := &Cond{Kind: kind}
+	c.Children = append(c.Children, child)
+	return child
+}
+
+// Remove takes one condition out of the tree, wherever it is, and reports
+// whether it found it. The root itself is never removed by this.
+func (c *Cond) Remove(target *Cond) bool {
+	for i, child := range c.Children {
+		if child == target {
+			c.Children = append(c.Children[:i], c.Children[i+1:]...)
+			return true
+		}
+		if child.Remove(target) {
+			return true
+		}
+	}
+	return false
+}
+
+// Walk calls f for every condition in the tree, depth first, with how deep
+// it sits and the operator holding it (nil for the roots).
+func (c *Cond) Walk(depth int, parent *Cond, f func(node, parent *Cond, depth int)) {
+	f(c, parent, depth)
+	for _, child := range c.Children {
+		child.Walk(depth+1, c, f)
+	}
+}
diff --git a/gui/internal/model/cond_test.go b/gui/internal/model/cond_test.go
new file mode 100644
index 0000000..7aa4772
--- /dev/null
+++ b/gui/internal/model/cond_test.go
@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package model
+
+import (
+	"strings"
+	"testing"
+
+	"krino/internal/sexp"
+)
+
+// parseOne reads one condition from text, for the tests below.
+func parseOne(t *testing.T, text string) *Cond {
+	t.Helper()
+	nodes, err := sexp.Parse("test", []byte(text))
+	if err != nil || len(nodes) != 1 {
+		t.Fatalf("%q does not parse: %v", text, err)
+	}
+	return ParseCond(nodes[0])
+}
+
+// TestCondRoundTrip: a condition read into the tree and written back is the
+// same condition, however deep it nests.
+func TestCondRoundTrip(t *testing.T) {
+	for _, text := range []string{
+		`(type pdf)`,
+		`(name "^faktura" "^fv")`,
+		`(duplicate)`,
+		`(and (type pdf) (content "invoice"))`,
+		`(or (and (type doc) (age > 90d)) (not (duplicate "~/docs")))`,
+		`(not (and (name "a;b") (size > 10M)))`,
+	} {
+		c := parseOne(t, text)
+		if got := c.Text(); got != text {
+			t.Errorf("round trip of %q gave %q", text, got)
+		}
+		if err := c.Parse(); err != nil {
+			t.Errorf("%q does not parse after the round trip: %v", text, err)
+		}
+	}
+}
+
+// TestCondTree: an operator holds its conditions, and the tree says how
+// deep each one sits.
+func TestCondTree(t *testing.T) {
+	c := parseOne(t, `(and (type pdf) (or (name "a") (name "b")))`)
+	if c.Kind != "and" || len(c.Children) != 2 {
+		t.Fatalf("tree = %+v", c)
+	}
+	var depths []string
+	c.Walk(0, nil, func(node, parent *Cond, depth int) {
+		depths = append(depths, strings.Repeat(" ", depth)+node.Kind)
+	})
+	want := []string{"and", " type", " or", "  name", "  name"}
+	if strings.Join(depths, "|") != strings.Join(want, "|") {
+		t.Errorf("walk = %v, want %v", depths, want)
+	}
+}
+
+// TestCondAddAndRemove: conditions go under an operator and come out again;
+// a test holds none.
+func TestCondAddAndRemove(t *testing.T) {
+	c := parseOne(t, `(and (type pdf))`)
+	added := c.Add("content")
+	if added == nil || len(c.Children) != 2 {
+		t.Fatalf("after adding: %+v", c)
+	}
+	added.Args = `"invoice"`
+	if got := c.Text(); got != `(and (type pdf) (content "invoice"))` {
+		t.Errorf("text = %q", got)
+	}
+	if !c.Remove(added) || len(c.Children) != 1 {
+		t.Errorf("removing left %+v", c)
+	}
+	if c.Children[0].Add("name") != nil {
+		t.Error("a test took a condition under it")
+	}
+	// Removing something that is not there changes nothing.
+	if c.Remove(&Cond{Kind: "name"}) {
+		t.Error("removed a condition that is not in the tree")
+	}
+}
+
+// TestCondEmptyOperator: an operator with nothing under it writes nothing
+// rather than "(and)", which krino would refuse, and says so when asked.
+func TestCondEmptyOperator(t *testing.T) {
+	c := &Cond{Kind: "and"}
+	if got := c.Text(); got != "" {
+		t.Errorf("text = %q, want nothing", got)
+	}
+	if err := c.Parse(); err == nil {
+		t.Error("an empty operator passed the check")
+	}
+}
diff --git a/gui/internal/model/newdir.go b/gui/internal/model/newdir.go
new file mode 100644
index 0000000..d0df6db
--- /dev/null
+++ b/gui/internal/model/newdir.go
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package model
+
+import (
+	"krino/internal/config"
+	"krino/internal/engine"
+)
+
+// AddDirectory writes dirs/NAME.conf from the template with path filled in
+// and adds NAME to krino.conf's include - exactly what `krino new NAME
+// PATH` does, through the same code, so a directory made in the window is
+// indistinguishable from one made on the command line (his report that the
+// window had no way to add one, 2026-09-17).
+//
+// It returns the new file's path. The caller reloads the engine: until it
+// does, the window knows nothing of the new directory.
+func AddDirectory(e *engine.Engine, name, path string) (string, error) {
+	return config.NewDir(e.MainFile, name, path)
+}
diff --git a/gui/internal/model/newdir_test.go b/gui/internal/model/newdir_test.go
new file mode 100644
index 0000000..19957d9
--- /dev/null
+++ b/gui/internal/model/newdir_test.go
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package model
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"krino/internal/engine"
+)
+
+// TestAddDirectory: a directory added in the window is one krino loads, its
+// file written from the template and its name in the include.
+func TestAddDirectory(t *testing.T) {
+	conf := "(path \"~/dl\")\n(rule \"all\" (move \"Out\"))\n"
+	e, h := sandboxDir(t, conf, map[string]string{"a.pdf": "one"})
+	target := filepath.Join(h, "papers")
+	if err := os.MkdirAll(target, 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	file, err := AddDirectory(e, "papers", target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(file); err != nil {
+		t.Fatalf("the file was not written: %v", err)
+	}
+	main, err := os.ReadFile(e.MainFile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(main), "papers") {
+		t.Errorf("the include does not name it:\n%s", main)
+	}
+
+	fresh, diags := engine.Load(e.MainFile)
+	if len(diags) > 0 {
+		t.Fatalf("the configuration no longer loads: %v", diags)
+	}
+	found := false
+	for _, d := range fresh.Dirs {
+		if d.Name == "papers" && d.Root == target {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("the new directory is not in the configuration: %+v", fresh.Dirs)
+	}
+	// And the window can open its rules straight away.
+	if _, err := OpenRules(fresh, "papers"); err != nil {
+		t.Errorf("its rules do not open: %v", err)
+	}
+}
+
+// TestAddDirectoryRefusals: the checks krino new makes are the checks the
+// window makes, because it is the same code.
+func TestAddDirectoryRefusals(t *testing.T) {
+	conf := "(path \"~/dl\")\n(rule \"all\" (move \"Out\"))\n"
+	e, h := sandboxDir(t, conf, map[string]string{"a.pdf": "one"})
+	for _, c := range []struct{ name, path, why string }{
+		{"has space", h, "a name with a space"},
+		{"check", h, "a krino command"},
+		{"dl", h, "a name already taken"},
+	} {
+		if _, err := AddDirectory(e, c.name, c.path); err == nil {
+			t.Errorf("%s was accepted", c.why)
+		}
+	}
+}
diff --git a/gui/internal/ui/forms.go b/gui/internal/ui/forms.go
index 8e1fd33..18a8b13 100644
--- a/gui/internal/ui/forms.go
+++ b/gui/internal/ui/forms.go
@@ -655,18 +655,18 @@ func hitsText(h *model.RuleHits, root string) string {
 
 // formEditor is the widgets of one form, and can write it back.
 type formEditor struct {
-	kind    model.FormKind
-	root    *gtk.Box
-	name    *gtk.Entry
-	conds   *gtk.Box
-	rows    []*condRow
-	acts    *gtk.Box
-	arows   []*actionRow
-	stop    *gtk.CheckButton
-	cse     *gtk.DropDown
-	fold    *gtk.DropDown
-	onConf  *gtk.DropDown
-	changed func()
+	kind       model.FormKind
+	root       *gtk.Box
+	name       *gtk.Entry
+	conds      *gtk.Box
+	conditions []*model.Cond
+	acts       *gtk.Box
+	arows      []*actionRow
+	stop       *gtk.CheckButton
+	cse        *gtk.DropDown
+	fold       *gtk.DropDown
+	onConf     *gtk.DropDown
+	changed    func()
 }
 
 func newFormEditor(form model.Form, changed func()) *formEditor {
@@ -685,15 +685,12 @@ func newFormEditor(form model.Form, changed func()) *formEditor {
 		fe.root.Append(field("Name", fe.name))
 	}
 
-	fe.conds = gtk.NewBox(gtk.OrientationVertical, 4)
+	fe.conds = gtk.NewBox(gtk.OrientationVertical, 2)
 	fe.root.Append(heading("Conditions - all of these must hold"))
 	fe.root.Append(fe.conds)
-	addCond := gtk.NewButtonWithLabel("+ test")
-	addCond.ConnectClicked(func() {
-		fe.addCond(nil)
-		changed()
-	})
-	fe.root.Append(leftAligned(addCond))
+	fe.root.Append(leftAligned(fe.addMenu(func(kind string) {
+		fe.conditions = append(fe.conditions, &model.Cond{Kind: kind})
+	})))
 
 	when := form.Rule.When
 	if form.Kind == model.ExcludeForm {
@@ -702,8 +699,9 @@ func newFormEditor(form model.Form, changed func()) *formEditor {
 		when = nil
 	}
 	for _, c := range when {
-		fe.addCond(c)
+		fe.conditions = append(fe.conditions, model.ParseCond(c))
 	}
+	fe.drawConds()
 
 	if form.Kind == model.RuleForm {
 		fe.acts = gtk.NewBox(gtk.OrientationVertical, 4)
@@ -738,11 +736,11 @@ func newFormEditor(form model.Form, changed func()) *formEditor {
 // text is the form as the printer writes it, from what the widgets hold.
 func (fe *formEditor) text() (string, error) {
 	var when []*sexp.Node
-	for _, row := range fe.rows {
-		if row.gone {
-			continue
+	for _, c := range fe.conditions {
+		text := c.Text()
+		if text == "" {
+			return "", fmt.Errorf("(%s ...) has no condition under it", c.Kind)
 		}
-		text := row.text()
 		nodes, err := sexp.Parse("form", []byte(text))
 		if err != nil {
 			return "", fmt.Errorf("%s: %v", text, err)
@@ -774,11 +772,128 @@ func (fe *formEditor) text() (string, error) {
 	return config.PrintRule(rule), nil
 }
 
-// addCond adds a condition row, filled in from n when there is one.
-func (fe *formEditor) addCond(n *sexp.Node) {
-	row := newCondRow(n, fe.changed)
-	fe.rows = append(fe.rows, row)
-	fe.conds.Append(row.root)
+// drawConds rebuilds the condition tree: one row per condition, indented by
+// how deep it sits, with the operators holding the conditions under them
+// (GUI design §5.1, his choice 2026-09-17).
+func (fe *formEditor) drawConds() {
+	for child := fe.conds.FirstChild(); child != nil; child = fe.conds.FirstChild() {
+		fe.conds.Remove(child)
+	}
+	for _, root := range fe.conditions {
+		root.Walk(0, nil, func(node, parent *model.Cond, depth int) {
+			fe.conds.Append(fe.condRow(node, parent, depth))
+		})
+	}
+}
+
+// addMenu is the "+" that puts a condition somewhere: a test, or one of the
+// three operators to hold more conditions under it.
+func (fe *formEditor) addMenu(add func(kind string)) *gtk.MenuButton {
+	box := gtk.NewBox(gtk.OrientationVertical, 0)
+	pop := gtk.NewPopover()
+	pop.SetChild(box)
+	button := gtk.NewMenuButton()
+	button.SetLabel("+")
+	button.SetTooltipText("add a test here, or and / or / not to hold more conditions")
+	button.SetPopover(pop)
+	for _, item := range []struct{ label, kind string }{
+		{"test", "type"},
+		{"and (all of these)", "and"},
+		{"or (any of these)", "or"},
+		{"not (none of these)", "not"},
+	} {
+		b := gtk.NewButtonWithLabel(item.label)
+		b.SetHasFrame(false)
+		b.SetHAlign(gtk.AlignFill)
+		kind := item.kind
+		b.ConnectClicked(func() {
+			pop.Popdown()
+			add(kind)
+			fe.drawConds()
+			fe.changed()
+		})
+		box.Append(b)
+	}
+	return button
+}
+
+// condRow is one line of the tree.
+func (fe *formEditor) condRow(node, parent *model.Cond, depth int) *gtk.Box {
+	row := gtk.NewBox(gtk.OrientationHorizontal, 6)
+	row.SetMarginStart(depth * 24)
+
+	kind := gtk.NewDropDownFromStrings(condItems())
+	if i := indexOf(condKinds, node.Kind); i >= 0 {
+		kind.SetSelected(uint(i))
+	}
+	kind.Connect("notify::selected", func() {
+		next := condKinds[kind.Selected()]
+		if next == node.Kind {
+			return
+		}
+		node.Kind = next
+		if !model.CondOps[next] {
+			node.Children = nil
+		}
+		fe.drawConds()
+		fe.changed()
+	})
+	row.Append(kind)
+
+	if model.CondOps[node.Kind] {
+		// An operator holds conditions rather than arguments. One button
+		// puts them under it: four side by side ran off the pane.
+		row.Append(fe.addMenu(func(kind string) { node.Add(kind) }))
+		row.Append(gtk.NewLabel(""))
+	} else {
+		args := gtk.NewEntry()
+		args.SetText(node.Args)
+		args.SetHExpand(true)
+		hint := condHints[node.Kind]
+		args.SetPlaceholderText(hint)
+		args.SetTooltipText(hint)
+		if isCompare(node.Kind) {
+			op := gtk.NewDropDownFromStrings(compareOps)
+			opText, value := splitCompare(node.Args)
+			if i := indexOf(compareOps, opText); i >= 0 {
+				op.SetSelected(uint(i))
+			}
+			args.SetText(value)
+			write := func() {
+				node.Args = compareOps[op.Selected()] + " " + strings.TrimSpace(args.Text())
+				fe.changed()
+			}
+			op.Connect("notify::selected", func() { write() })
+			args.ConnectChanged(func() { write() })
+			row.Append(op)
+		} else {
+			args.ConnectChanged(func() {
+				node.Args = strings.TrimSpace(args.Text())
+				fe.changed()
+			})
+		}
+		row.Append(args)
+	}
+
+	remove := gtk.NewButtonWithLabel("-")
+	remove.SetHasFrame(false)
+	remove.SetTooltipText("take this condition out")
+	remove.ConnectClicked(func() {
+		if parent != nil {
+			parent.Remove(node)
+		} else {
+			for i, c := range fe.conditions {
+				if c == node {
+					fe.conditions = append(fe.conditions[:i], fe.conditions[i+1:]...)
+					break
+				}
+			}
+		}
+		fe.drawConds()
+		fe.changed()
+	})
+	row.Append(remove)
+	return row
 }
 
 // addAction adds an action row.
diff --git a/gui/internal/ui/plan.go b/gui/internal/ui/plan.go
index 0a9b718..0adc6b1 100644
--- a/gui/internal/ui/plan.go
+++ b/gui/internal/ui/plan.go
@@ -469,6 +469,33 @@ func (p *planView) showPath() {
 	p.path.SetText("no directory is included; add one with: krino new NAME PATH")
 }
 
+// currentName is the directory the picker names, "" when none.
+func (p *planView) currentName() string {
+	if d := p.currentDir(); d != nil {
+		return d.Name
+	}
+	return ""
+}
+
+// refreshDirs rebuilds the directory picker after the configuration
+// changed - a directory added in the Rules tab appears here too.
+func (p *planView) refreshDirs(keep string) {
+	names := make([]string, len(p.w.engine.Dirs))
+	for i, d := range p.w.engine.Dirs {
+		names[i] = d.Name
+	}
+	if len(names) == 0 {
+		names = []string{"none"}
+	}
+	p.dirs.SetModel(gtk.NewStringList(names))
+	for i, d := range p.w.engine.Dirs {
+		if d.Name == keep {
+			p.dirs.SetSelected(uint(i))
+		}
+	}
+	p.showPath()
+}
+
 // currentDir is the directory the picker names.
 func (p *planView) currentDir() *engine.Dir {
 	i := int(p.dirs.Selected())
diff --git a/gui/internal/ui/rules.go b/gui/internal/ui/rules.go
index 3bae8df..5cce276 100644
--- a/gui/internal/ui/rules.go
+++ b/gui/internal/ui/rules.go
@@ -77,6 +77,10 @@ func newRulesView(w *Window) *rulesView {
 	bar.SetMarginBottom(6)
 	bar.Append(gtk.NewLabel("Rules for"))
 	bar.Append(r.dirs)
+	add := gtk.NewButtonWithLabel("Add directory...")
+	add.SetTooltipText("sort another directory: writes dirs/NAME.conf from the template and adds NAME to krino.conf's include, as krino new does")
+	add.ConnectClicked(func() { r.w.addDirectory() })
+	bar.Append(add)
 	r.check = gtk.NewLabel("")
 	r.check.SetXAlign(0)
 	r.check.SetHExpand(true)
@@ -269,6 +273,22 @@ func (r *rulesView) textChangedByForm() {
 	r.runCheck()
 }
 
+// refreshDirs rebuilds the picker after the configuration changed.
+func (r *rulesView) refreshDirs(keep string) {
+	r.names = model.RuleFiles(r.w.engine)
+	names := r.names
+	if len(names) == 0 {
+		names = []string{"none"}
+	}
+	r.dirs.SetModel(gtk.NewStringList(names))
+	for i, n := range r.names {
+		if n == keep {
+			r.dirs.SetSelected(uint(i))
+		}
+	}
+	r.open(r.selectedName())
+}
+
 // selectedName is the directory the picker names, "" when none is offered.
 func (r *rulesView) selectedName() string {
 	i := int(r.dirs.Selected())
diff --git a/gui/internal/ui/window.go b/gui/internal/ui/window.go
index 12e94a3..ce991d8 100644
--- a/gui/internal/ui/window.go
+++ b/gui/internal/ui/window.go
@@ -149,6 +149,68 @@ func (w *Window) confirmLeaving() {
 	d.Show()
 }
 
+// addDirectory asks for a name and a path and makes krino sort that
+// directory too - the window had no way to do it (his report, 2026-09-17).
+func (w *Window) addDirectory() {
+	d := gtk.NewWindow()
+	d.SetTitle("Add a directory")
+	d.SetTransientFor(&w.win.Window)
+	d.SetModal(true)
+	d.SetDefaultSize(520, 200)
+
+	name := gtk.NewEntry()
+	name.SetPlaceholderText("papers")
+	name.SetTooltipText("the name krino knows it by: letters, digits, '.', '_' and '-'; its rules go in dirs/NAME.conf")
+	path := gtk.NewEntry()
+	path.SetPlaceholderText("~/papers")
+	path.SetHExpand(true)
+	path.SetTooltipText("the directory to sort")
+
+	note := gtk.NewLabel("")
+	note.SetXAlign(0)
+	note.SetWrap(true)
+
+	box := gtk.NewBox(gtk.OrientationVertical, 8)
+	box.SetMarginStart(12)
+	box.SetMarginEnd(12)
+	box.SetMarginTop(12)
+	box.SetMarginBottom(12)
+	box.Append(field("name", name))
+	box.Append(field("path", path))
+	box.Append(note)
+
+	create := gtk.NewButtonWithLabel("Add")
+	create.AddCSSClass("suggested-action")
+	cancel := gtk.NewButtonWithLabel("Cancel")
+	cancel.ConnectClicked(func() { d.Close() })
+	buttons := gtk.NewBox(gtk.OrientationHorizontal, 6)
+	buttons.SetHAlign(gtk.AlignEnd)
+	buttons.Append(cancel)
+	buttons.Append(create)
+	box.Append(buttons)
+
+	create.ConnectClicked(func() {
+		file, err := model.AddDirectory(w.engine, strings.TrimSpace(name.Text()), strings.TrimSpace(path.Text()))
+		if err != nil {
+			note.SetText(escape(err.Error()))
+			note.AddCSSClass("error")
+			return
+		}
+		added := strings.TrimSpace(name.Text())
+		if err := w.reloadEngine(); err != nil {
+			note.SetText(escape(err.Error()))
+			note.AddCSSClass("error")
+			return
+		}
+		w.plan.refreshDirs(w.plan.currentName())
+		w.rules.refreshDirs(added)
+		w.setStatus("added %s; its rules are in %s", escape(added), escape(xdg.Abbrev(file)))
+		d.Close()
+	})
+	d.SetChild(box)
+	d.Show()
+}
+
 // savePrefsSoon writes the preferences a moment after the last change, so
 // dragging a divider does not write the file on every pixel.
 func (w *Window) savePrefsSoon() {
diff --git a/man/krino-gui.1 b/man/krino-gui.1
index 10b6da6..72804ac 100644
--- a/man/krino-gui.1
+++ b/man/krino-gui.1
@@ -129,9 +129,26 @@ its name, its conditions, its actions in order,
 .Ic (stop) ,
 and the three rule settings; the directory's form holds the settings
 .Xr krino.conf 5
-documents, an empty field meaning krino's default. A condition is its kind
-and its arguments as the file writes them, so no test is out of reach and
-none is silently rewritten.
+documents, an empty field meaning krino's default. The conditions are a tree:
+each line is a test - its kind and its arguments as the file writes them, so
+no test is out of reach and none is silently rewritten - or one of
+.Ic and ,
+.Ic or
+and
+.Ic not
+holding the conditions indented under it. The
+.Cm +
+on a line adds a test or another operator under it, and
+.Cm -
+takes one out.
+.Cm Add directory
+writes
+.Pa dirs/NAME.conf
+from the template and adds the name to
+.Pa krino.conf Ns 's
+include, exactly as
+.Cm krino new
+does.
 .Cm Add rule
 inserts after the selected rule,
 .Cm Delete