Agenda prefix format and log mode !73

merged merged by cmc on 2026-10-06 02:50 UTC · krz/orgstar:agenda-prefix-log into main

10 files changed, +392 −28

Layout: unified · split

Sources/OrgApp/AgendaModel.swift +2 −2

	@@ -65,9 +65,9 @@ public final class AgendaModel {
65	case .agenda:	65	case .agenda:
66	days = Agenda.list(all, start: first, days: span, today: today, now: (clock.hour ?? 0, clock.minute ?? 0), options: options)	66	days = Agenda.list(all, start: first, days: span, today: today, now: (clock.hour ?? 0, clock.minute ?? 0), options: options)
67	case .todo(let keywords):	67	case .todo(let keywords):
68	list = Agenda.todoList(all, keywords: keywords)	68	list = Agenda.todoList(all, keywords: keywords, options: options)
69	case .match(let match, let todoOnly):	69	case .match(let match, let todoOnly):
70	list = Agenda.tagsMatch(all, match: match, todoOnly: todoOnly, now: now, calendar: calendar)	70	list = Agenda.tagsMatch(all, match: match, todoOnly: todoOnly, now: now, calendar: calendar, options: options)
71	}	71	}
72	return (days, list)	72	return (days, list)
73	}.value	73	}.value

Sources/OrgApp/EmacsImport.swift +10 −1

             } else {
                 add(name, .bool(truthy))
             }
+        case "org-agenda-prefix-format":
+            if let s = value.string {
+                for view in ["agenda", "todo", "tags"] { add("org-agenda-prefix-format.\(view)", .string(s)) }
+            } else {
+                for entry in value.elements ?? [] {
+                    guard case .dotted(let key, let format) = entry, let view = key.first?.symbol, let s = format.string else { continue }
+                    if ["agenda", "todo", "tags"].contains(view) { add("org-agenda-prefix-format.\(view)", .string(s)) }
+                }
+            }
         case "org-log-done":
             switch value.symbol {
             case "nil": add(name, .string("nil"))
         var problems: [String] = []
         for item in items {
             guard case .setting(let key, let value) = item.change,
-                  let setting = UserConfig.settings.first(where: { $0.key == key }) else { continue }
+                  let setting = UserConfig.settings.first(where: { $0.path == key || $0.key == key }) else { continue }
             if let problem = UserConfig.store(value, setting, in: defaults) { problems.append(problem) } else { settings += 1 }
         }
         for item in items {

Sources/OrgApp/UserConfig.swift +6

                 comment: "the agenda's first day: \"-3d\", \"+0d\"", legacy: "agenda.start-offset"),
         Setting(section: "", key: "appt-message-warning-time", defaultsKey: "reminderLead", kind: .integer, fallback: .integer(12),
                 comment: "minutes of warning before timed entries; APPT_WARNTIME overrides", legacy: "agenda.reminder-lead"),
+        Setting(section: "org-agenda-prefix-format", key: "agenda", defaultsKey: "agendaPrefixAgenda", kind: .string, fallback: .string(PrefixFormat.defaults["agenda"]!),
+                comment: "%c category, %t time, %s scheduled/deadline, %e effort, %l level, %b outline path; %-12 pads", legacy: ""),
+        Setting(section: "org-agenda-prefix-format", key: "todo", defaultsKey: "agendaPrefixTodo", kind: .string, fallback: .string(PrefixFormat.defaults["todo"]!),
+                comment: "the TODO list", legacy: ""),
+        Setting(section: "org-agenda-prefix-format", key: "tags", defaultsKey: "agendaPrefixTags", kind: .string, fallback: .string(PrefixFormat.defaults["tags"]!),
+                comment: "tag and property matches", legacy: ""),
         Setting(section: "theme", key: "font", defaultsKey: "themeFont", kind: .string, fallback: .string(""),
                 comment: "a monospaced font family; \"\" for the system's", legacy: ""),
         Setting(section: "theme", key: "font-size", defaultsKey: "themeFontSize", kind: .integer, fallback: .integer(13),

Sources/OrgCore/Agenda/Agenda.swift +84 −14

         case currentTime
         case todo
         case tagsMatch = "tagsmatch"
+        /// Log mode: a closed entry, a clock line, a state change.
+        case closed, clock, state
     }
     public let kind: Kind
     public let habit: Habit?
     /// The line as org prints it, with one space before the tags.
     public let line: String
+    /// What `org-agenda-prefix-format` puts before the heading text.
+    public var prefix = ""
 }
 public struct AgendaDay: Sendable, Equatable {
     public var gridTrailing = " ┄┄┄┄┄ "
     public var gridLine = "┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄"
     public var currentTimeLine = "← now ───────────────────────────────────────────────"
+    /// `org-agenda-prefix-format`, by view: `agenda`, `todo`, `tags`, `search`.
+    public var prefixFormat = PrefixFormat.defaults
+    /// Log mode (`l`): closed entries and clocked time on each day.
+    public var logMode = false
+    /// `org-agenda-log-mode-items`.
+    public var logItems: Set<String> = ["closed", "clock"]
     public init() {}
+    func prefix(_ view: String) -> PrefixFormat {
+        PrefixFormat(prefixFormat[view] ?? PrefixFormat.defaults[view]!)
+    }
     /// What Emacs shows without a graphical display.
     public static let terminal: AgendaOptions = {
         var options = AgendaOptions()
     /// `org-agenda-get-day-entries` with the default entry types.
     static func entries(_ source: AgendaSource, day: Int, today: Int, options: AgendaOptions) -> [AgendaItem] {
         let deadlines = self.deadlines(source, day: day, today: today, options: options)
-        return deadlines + scheduled(source, day: day, today: today, options: options) + blocks(source, day: day, options: options)
+        return (options.logMode ? progress(source, day: day, options: options) : []) + deadlines + scheduled(source, day: day, today: today, options: options) + blocks(source, day: day, options: options)
             + timestamps(source, day: day, today: today, options: options)
     }
             let upcoming = isToday && deadline > today
             items.append(format(
                 source, heading, kind: upcoming ? .upcomingDeadline : .deadline, marker: offset, extra: extra,
-                dotime: time, removing: nil, trailing: options.gridTrailing, urgency: { (isToday ? -diff : 0) + $0 }
+                dotime: time, removing: nil, trailing: options.gridTrailing, prefix: options.prefix("agenda"), urgency: { (isToday ? -diff : 0) + $0 }
             ))
         }
         return items
             let habit = heading.isHabit ? heading.habit : nil
             items.append(format(
                 source, heading, kind: past ? .pastScheduled : .scheduled, marker: offset, extra: extra,
-                dotime: time, removing: nil, trailing: options.gridTrailing, habit: habit,
+                dotime: time, removing: nil, trailing: options.gridTrailing, prefix: options.prefix("agenda"), habit: habit,
                 urgency: { habit?.urgency(today: today) ?? 99 + diff + $0 }
             ))
         }
             } else {
                 dotime = nil
             }
-            items.append(format(source, heading, kind: .block, marker: block.marker, extra: extra, dotime: dotime, removing: nil, trailing: options.gridTrailing, urgency: { $0 }))
+            items.append(format(source, heading, kind: .block, marker: block.marker, extra: extra, dotime: dotime, removing: nil, trailing: options.gridTrailing, prefix: options.prefix("agenda"), urgency: { $0 }))
+        }
+        return items
+    }
+    /// `org-agenda-get-progress`.
+    static func progress(_ source: AgendaSource, day current: Int, options: AgendaOptions) -> [AgendaItem] {
+        let date = Days.date(current)
+        let literal = String(format: "%04d-%02d-%02d", date.year, date.month, date.day)
+        var items: [AgendaItem] = []
+        for entry in source.progress where entry.date == literal {
+            let kind: AgendaItem.Kind
+            let extra: String
+            switch entry.kind {
+            case .closed:
+                guard options.logItems.contains("closed") else { continue }
+                (kind, extra) = (.closed, "Closed:    ")
+            case .clock:
+                guard options.logItems.contains("clock") else { continue }
+                (kind, extra) = (.clock, "Clocked:   (\(entry.clocked))")
+            case .state:
+                guard options.logItems.contains("state") else { continue }
+                (kind, extra) = (.state, "State:     (\(entry.state ?? ""))")
+            }
+            let heading = source.headings[entry.heading]
+            var head = heading.head
+            if let note = entry.note {
+                // Before the tags, as org adds it.
+                if let tags = head.range(of: "([ \\t]+)(:[^ \\n\\t]*?:)[ \\t]*$", options: .regularExpression) {
+                    let tagText = head[tags].trimmingCharacters(in: .whitespaces)
+                    head = head[..<tags.lowerBound] + " - " + note + " " + tagText
+                } else {
+                    head += " - " + note
+                }
+            }
+            items.append(format(
+                source, heading, kind: kind, marker: entry.offset, extra: extra, dotime: .only(entry.timestamp), removing: nil,
+                trailing: options.gridTrailing, prefix: options.prefix("agenda"), head: head, urgency: { _ in 100_000 }
+            ))
         }
         return items
     }
             let heading = source.headings[stamp.heading]
             items.append(format(
                 source, heading, kind: .timestamp, marker: stamp.offset, extra: "",
-                dotime: .string(timestamp), removing: stampActive, trailing: options.gridTrailing,
+                dotime: .string(timestamp), removing: stampActive, trailing: options.gridTrailing, prefix: options.prefix("agenda"),
                 urgency: { heading.isHabit ? heading.habit?.urgency(today: today) ?? $0 : $0 }
             ))
         }
         case string(String)
         /// Look for a time in the heading only.
         case headline
+        /// In the string only (`org-agenda-search-headline-for-time` nil).
+        case only(String)
     }
     static let tagGroup = try! NSRegularExpression(pattern: "[ \\t]+(:([\\p{L}\\p{N}_@#%:]+):)[ \\t]*$")
     /// `org-agenda-highlight-todo`.
     static func format(
         _ source: AgendaSource, _ heading: AgendaSource.Heading, kind: AgendaItem.Kind, marker: Int,
-        extra: String, dotime: Dotime?, removing: NSRegularExpression?, trailing: String, hasTime: Bool = true,
+        extra: String, dotime: Dotime?, removing: NSRegularExpression?, trailing: String, prefix prefixFormat: PrefixFormat,
-        habit: Habit? = nil, urgency: (Int) -> Int
+        head: String? = nil, habit: Habit? = nil, urgency: (Int) -> Int
     ) -> AgendaItem {
-        var txt = heading.head.trimmingCharacters(in: .whitespaces)
+        var txt = (head ?? heading.head).trimmingCharacters(in: .whitespaces)
         // `org-agenda-fix-displayed-tags`: the heading's tags are replaced by the full list.
         let tags = heading.tags
         if let m = tagGroup.firstMatch(in: txt, range: NSRange(location: 0, length: (txt as NSString).length)) {
             tagString = ":" + parts.joined(separator: ":") + (haveInherited ? "::" : ":")
         }
-        let timed = timeFields(&txt, tagString: tagString, dotime: dotime, trailing: trailing, removeTimes: hasTime)
+        let timed = timeFields(&txt, tagString: tagString, dotime: dotime, trailing: trailing, removeTimes: prefixFormat.hasTime)
         if let removing {
             while let m = removing.firstMatch(in: txt, range: NSRange(location: 0, length: (txt as NSString).length)) {
                 txt = (txt as NSString).replacingCharacters(in: m.range, with: "")
             }
         }
         let category = heading.category
-        // ` %i %-12:c%?-12t% s` in the agenda, ` %i %-12:c` in TODO and tags lists.
+        let prefix = prefixFormat.render([
-        let prefix = "  " + pad(category.isEmpty ? "" : category + ":", 12)
+            "c": category, "t": timed.time, "s": habit == nil ? extra : "", "l": String(repeating: " ", count: heading.level),
-            + (hasTime ? (timed.time.isEmpty ? "" : pad(timed.time, 12)) + (extra.isEmpty ? "" : extra + " ") : "")
+            "e": heading.properties["EFFORT"] ?? "", "b": breadcrumbs(source, heading), "T": tags.last?.name ?? "",
+        ])
         txt = highlightTodo(txt, keywords: source.keywords)
         let priority = Self.priority(prefix + txt, source.priorities)
         return AgendaItem(
             timeOfDay: timed.timeOfDay, time: timed.time, extra: extra, text: txt, tags: tags.map(\.name),
             todo: heading.todo, isDone: heading.isDone, urgency: urgency(priority),
             warntime: heading.properties["APPT_WARNTIME"].flatMap { Int($0.trimmingCharacters(in: .whitespaces)) }, habit: habit,
-            line: prefix + txt + (tagString.isEmpty ? "" : " " + tagString)
+            line: prefix + txt + (tagString.isEmpty ? "" : " " + tagString), prefix: prefix
         )
     }
+    /// `%b`: the outline path above the heading, each title followed by `->`.
+    static func breadcrumbs(_ source: AgendaSource, _ heading: AgendaSource.Heading) -> String {
+        guard let index = source.headings.firstIndex(where: { $0.start == heading.start }) else { return "" }
+        var path: [String] = []
+        var level = heading.level
+        for candidate in source.headings[..<index].reversed() where candidate.level < level {
+            let title = candidate.title.replacingOccurrences(of: "\\[[0-9]+%\\]|\\[[0-9]+/[0-9]+\\]", with: "", options: .regularExpression)
+            path.insert(Links.displayFormat(title).trimmingCharacters(in: .whitespaces), at: 0)
+            level = candidate.level
+            if level == 1 { break }
+        }
+        return path.isEmpty ? "" : path.joined(separator: "->") + "->"
+    }
     /// The time-of-day part of `org-agenda-format-item`: finds the time, removes it from the
     /// text, and formats the `%t` field.
     static func timeFields(_ txt: inout String, tagString: String, dotime: Dotime?, trailing: String, removeTimes: Bool = true) -> (timeOfDay: Int?, time: String) {
         switch dotime {
         case .string(let s): containing = s + withoutStamps
         case .headline: containing = withoutStamps
+        case .only(let s): containing = s
         }
         guard let timeOfDay = time(of: containing) else { return (nil, "") }
         let ns = containing as NSString
             return AgendaItem(
                 kind: kind, path: nil, headingOffset: nil, headingLine: nil, markerOffset: nil, category: "", timeOfDay: timed.timeOfDay,
                 time: timed.time, extra: "", text: txt, tags: [], todo: nil, isDone: false, urgency: 0, warntime: nil, habit: nil,
-                line: "  " + pad("", 12) + pad(timed.time, 12) + txt
+                line: options.prefix("agenda").render(["t": timed.time]) + txt, prefix: options.prefix("agenda").render(["t": timed.time])
             )
         }
         var new = options.gridTimes.reversed().map { t in

Sources/OrgCore/Agenda/AgendaSearch.swift +7 −4

 extension Agenda {
     /// `org-todo-list`: unfinished entries, or with `keywords` (`WAIT|HOLD`) those with any of
     /// the keywords.
-    public static func todoList(_ sources: [AgendaSource], keywords: String? = nil) -> [AgendaItem] {
+    public static func todoList(_ sources: [AgendaSource], keywords: String? = nil, options: AgendaOptions = AgendaOptions()) -> [AgendaItem] {
         let selected = keywords.map { $0.split(separator: "|").map(String.init) }
         var items: [AgendaItem] = []
         for source in sources {
                 }
                 items.append(format(
                     source, heading, kind: .todo, marker: heading.start, extra: "", dotime: .headline, removing: nil,
-                    trailing: "", hasTime: false, urgency: { 1 + $0 }
+                    trailing: "", prefix: options.prefix("todo"), urgency: { 1 + $0 }
                 ))
             }
         }
     /// `org-tags-view`: entries matching a tags/property/TODO match string. `todoOnly` keeps
     /// unfinished TODO entries, as `M` does.
-    public static func tagsMatch(_ sources: [AgendaSource], match: String, todoOnly: Bool = false, now: Date = Date(), calendar: Calendar = .current) -> [AgendaItem] {
+    public static func tagsMatch(
+        _ sources: [AgendaSource], match: String, todoOnly: Bool = false, now: Date = Date(), calendar: Calendar = .current,
+        options: AgendaOptions = AgendaOptions()
+    ) -> [AgendaItem] {
         let matcher = TagsMatcher(match, todoOnly: todoOnly)
         var items: [AgendaItem] = []
         for source in sources {
                 guard matcher.matches(heading, in: source, now: now, calendar: calendar), !heading.skipped else { continue }
                 items.append(format(
                     source, heading, kind: .tagsMatch, marker: heading.start, extra: "", dotime: nil, removing: nil,
-                    trailing: "", hasTime: false, urgency: { $0 }
+                    trailing: "", prefix: options.prefix("tags"), urgency: { $0 }
                 ))
             }
         }

Sources/OrgCore/Agenda/AgendaSource.swift +61

	@@ -56,9 +56,28 @@ public struct AgendaSource: Sendable {
56	let heading: Int	56	let heading: Int
57	}	57	}
58		58
		59	/// A `CLOSED:`, `CLOCK:` or `- State "…"` line, for log mode (`org-agenda-get-progress`).
		60	struct Progress: Sendable {
		61	enum Kind: Sendable { case closed, clock, state }
		62	let kind: Kind
		63	let offset: Int
		64	let heading: Int
		65	/// `YYYY-MM-DD` of the first timestamp.
		66	let date: String
		67	/// The timestamp, from the keyword; a clock's ends with its end time (`[… 10:00-11:30]`).
		68	let timestamp: String
		69	/// A clock's duration, or `-`.
		70	let clocked: String
		71	/// The state a note records.
		72	let state: String?
		73	/// The first line of the note under it.
		74	let note: String?
		75	}
		76
59	let headings: [Heading]	77	let headings: [Heading]
60	let stamps: [Stamp]	78	let stamps: [Stamp]
61	let blocks: [Block]	79	let blocks: [Block]
		80	let progress: [Progress]
62	/// The file's TODO keywords, active and done.	81	/// The file's TODO keywords, active and done.
63	let keywords: [String]	82	let keywords: [String]
64	let priorities: Priorities	83	let priorities: Priorities
	@@ -243,6 +262,48 @@ public struct AgendaSource: Sendable {
243	blocks.append(Block(start: ns.substring(with: m.range(at: 1)), end: ns.substring(with: m.range(at: 2)), marker: point, heading: owner))	262	blocks.append(Block(start: ns.substring(with: m.range(at: 1)), end: ns.substring(with: m.range(at: 2)), marker: point, heading: owner))
244	}	263	}
245	self.blocks = blocks	264	self.blocks = blocks
		265
		266	// Log lines: org searches the raw text, then the heading above each match.
		267	let keywordPattern = keywords.map(NSRegularExpression.escapedPattern(for:)).joined(separator: "\|")
		268	let logLine = try! NSRegularExpression(pattern: "(\\bCLOSED:\|\\bCLOCK:\|- +State \"(\(keywordPattern.isEmpty ? "(?!)" : keywordPattern))\".?) \\[([0-9]{4}-[0-9]{2}-[0-9]{2})")
		269	let inactive = try! NSRegularExpression(pattern: "\\[([0-9]{4}-[0-9]{2}-[0-9]{2}( +[^\\]+0-9>\\r\\n -]+)?( +([0-9]{1,2}):([0-9]{2}))?)\\]")
		270	let clockEnd = try! NSRegularExpression(pattern: "([0-9]{1,2}:[0-9]{2})\\].*?([0-9]{1,2}:[0-9]{2})")
		271	let stateNote = try! NSRegularExpression(pattern: ".\\\\\\n[ \\t]([^-\\n \\t].?)[ \\t]$", options: .anchorsMatchLines)
		272	let clockNote = try! NSRegularExpression(pattern: ".\\n[ \\t]-[ \\t]+([^-\\n \\t].?)[ \\t]$", options: .anchorsMatchLines)
		273	var progress: [Progress] = []
		274	for m in logLine.matches(in: text, range: NSRange(location: 0, length: ns.length)) {
		275	guard let owner = heading(at: m.range.location), !skipped[owner] else { continue }
		276	let keyword = ns.substring(with: m.range(at: 1))
		277	let kind: Progress.Kind = keyword == "CLOSED:" ? .closed : keyword == "CLOCK:" ? .clock : .state
		278	var timestamp = restOfLine(m.range.location)
		279	var clocked = "-"
		280	let tns = timestamp as NSString
		281	if let ts = inactive.firstMatch(in: timestamp, range: NSRange(location: 0, length: tns.length)) {
		282	let rest = tns.substring(from: NSMaxRange(ts.range))
		283	timestamp = tns.substring(to: NSMaxRange(ts.range))
		284	let rns = rest as NSString
		285	if kind == .clock, let end = clockEnd.firstMatch(in: rest, range: NSRange(location: 0, length: rns.length)) {
		286	timestamp = String(timestamp.dropLast()) + "-" + rns.substring(with: end.range(at: 1)) + "]"
		287	clocked = rns.substring(with: end.range(at: 2))
		288	}
		289	}
		290	// The note: after a state line ending in `\\`, or a list item under a clock line.
		291	var note: String?
		292	let after = NSMaxRange(m.range)
		293	let notePattern: NSRegularExpression? = switch kind {
		294	case .state: stateNote
		295	case .clock: clockNote
		296	case .closed: nil
		297	}
		298	if let notePattern, let n = notePattern.firstMatch(in: text, options: .anchored, range: NSRange(location: after, length: ns.length - after)) {
		299	note = ns.substring(with: n.range(at: 1))
		300	}
		301	progress.append(Progress(
		302	kind: kind, offset: m.range.location, heading: owner, date: ns.substring(with: m.range(at: 3)), timestamp: timestamp,
		303	clocked: clocked, state: m.range(at: 2).location == NSNotFound ? nil : ns.substring(with: m.range(at: 2)), note: note
		304	))
		305	}
		306	self.progress = progress
246	}	307	}
247		308
248	/// `org-ts--internal-regexp`.	309	/// `org-ts--internal-regexp`.

Sources/OrgCore/Agenda/PrefixFormat.swift added +82

@@ -0,0 +1,82 @@
	1	import Foundation
	2
	3	/// `org-agenda-prefix-format` for one view, compiled as `org-compile-prefix-format` does:
	4	/// `%c` category, `%t` time, `%l` level, `%s` extra, `%e` effort, `%b` breadcrumbs, `%i` icon
	5	/// (none in Orgstar), each with an optional `?` (empty when the value is), a `%-12`-style
	6	/// width with an optional `.N` limit on categories, and a punctuation character added after a
	7	/// non-empty value. `%(…)` forms run Lisp; they are empty here.
	8	public struct PrefixFormat: Sendable, Equatable {
	9	enum Piece: Sendable, Equatable {
	10	case literal(String)
	11	case field(key: Character, optional: Bool, width: String, punctuation: String)
	12	}
	13
	14	let pieces: [Piece]
	15	/// `org-prefix-has-time`: times move out of the heading into the prefix.
	16	let hasTime: Bool
	17	/// `.N` in the category width: categories this long or longer are cut to N - 1.
	18	let categoryMaxLength: Int?
	19
	20	public init(_ format: String) {
	21	let regex = try! NSRegularExpression(pattern: "%(\\?)?([-+]?[0-9.]*)([ .;,:!?=\|/<>]?)([cltseib]\|\$.+?\$)")
	22	let ns = format as NSString
	23	var pieces: [Piece] = []
	24	var hasTime = false
	25	var maxLength: Int?
	26	var at = 0
	27	for m in regex.matches(in: format, range: NSRange(location: 0, length: ns.length)) {
	28	if m.range.location > at { pieces.append(.literal(ns.substring(with: NSRange(location: at, length: m.range.location - at)))) }
	29	let key = ns.substring(with: m.range(at: 4))
	30	let width = ns.substring(with: m.range(at: 2))
	31	if key.hasPrefix("(") {
	32	pieces.append(.field(key: "(", optional: false, width: width, punctuation: ""))
	33	} else {
	34	let k = key.first!
	35	if k == "t" { hasTime = true }
	36	if k == "c", let dot = width.firstIndex(of: ".") { maxLength = Int(width[width.index(after: dot)...].prefix { $0.isNumber }) }
	37	pieces.append(.field(key: k, optional: m.range(at: 1).location != NSNotFound, width: width, punctuation: ns.substring(with: m.range(at: 3))))
	38	}
	39	at = NSMaxRange(m.range)
	40	}
	41	if at < ns.length { pieces.append(.literal(ns.substring(from: at))) }
	42	self.pieces = pieces
	43	self.hasTime = hasTime
	44	self.categoryMaxLength = maxLength
	45	}
	46
	47	/// The prefix for these values, by field key.
	48	func render(_ values: [Character: String]) -> String {
	49	var out = ""
	50	for piece in pieces {
	51	switch piece {
	52	case .literal(let s): out += s
	53	case .field(let key, let optional, let width, let punctuation):
	54	var value = values[key] ?? ""
	55	if key == "c", let max = categoryMaxLength, value.count >= max { value = String(value.prefix(max - 1)) }
	56	if value.isEmpty {
	57	out += optional ? "" : Self.format("", width)
	58	} else {
	59	out += Self.format(value + punctuation, width)
	60	}
	61	}
	62	}
	63	return out
	64	}
	65
	66	/// Emacs `format` with `%WIDTHs` or `%-WIDTH.PRECISIONs`.
	67	static func format(_ s: String, _ spec: String) -> String {
	68	var spec = Substring(spec)
	69	let left = spec.first == "-"
	70	if left \|\| spec.first == "+" { spec = spec.dropFirst() }
	71	let parts = spec.split(separator: ".", omittingEmptySubsequences: false)
	72	let width = Int(parts.first ?? "") ?? 0
	73	var value = s
	74	if parts.count > 1, let precision = Int(parts[1]) { value = String(value.prefix(precision)) }
	75	let padding = String(repeating: " ", count: max(0, width - displayWidth(value)))
	76	return left ? value + padding : padding + value
	77	}
	78
	79	public static let defaults: [String: String] = [
	80	"agenda": " %i %-12:c%?-12t% s", "todo": " %i %-12:c", "tags": " %i %-12:c", "search": " %i %-12:c",
	81	]
	82	}

Sources/Orgstar/AgendaView.swift +38 −3

 /// The agenda window: the day/week agenda, the TODO list, tag matches and saved views.
 /// Return or a double click jumps to the entry in the main window. Keys as in Emacs's agenda:
-/// f/b/. move the span, g refreshes, t cycles the TODO state, +/- change the priority, : or
+/// f/b/. move the span, g refreshes, l shows the log (closed and clocked), t cycles the TODO state, +/- change the priority, : or
 /// C-c C-q sets tags, C-c C-s / C-c C-d schedule and set a deadline, S-→/S-← move the date.
 struct AgendaView: View {
     let workspace: WorkspaceModel
     @State private var prompt: PendingPrompt?
     @State private var promptText = ""
     @State private var prefix = false
+    @State private var logMode = false
     @AppStorage("agendaSpan") private var span = 10
     @AppStorage("agendaStartOffset") private var startOffset = -3
     @AppStorage("agendaSubfolders") private var includeSubfolders = false
+    @AppStorage("agendaPrefixAgenda") private var prefixAgenda = PrefixFormat.defaults["agenda"]!
+    @AppStorage("agendaPrefixTodo") private var prefixTodo = PrefixFormat.defaults["todo"]!
+    @AppStorage("agendaPrefixTags") private var prefixTags = PrefixFormat.defaults["tags"]!
     @Environment(\.openWindow) private var openWindow
     static let match = "Match…"
         var span: Int
         var startOffset: Int
         var includeSubfolders: Bool
+        var prefix: [String]
+        var logMode: Bool
         var files: Int
         var changed: Int?
         var edits: Int
     private var refreshKey: RefreshKey {
         RefreshKey(
-            mode: agenda.mode, start: agenda.start, span: span, startOffset: startOffset, includeSubfolders: includeSubfolders,
+            mode: agenda.mode, start: agenda.start, span: span, startOffset: startOffset, includeSubfolders: includeSubfolders, prefix: [prefixAgenda, prefixTodo, prefixTags], logMode: logMode,
             files: workspace.files.count, changed: workspace.changedFile?.version, edits: session.editVersion,
             path: session.path, tick: tick
         )
     private var isMatch: Bool { viewName == Self.match || viewName == Self.todoMatch }
+    private var customPrefix: Bool {
+        switch agenda.mode {
+        case .agenda: prefixAgenda != PrefixFormat.defaults["agenda"]
+        case .todo: prefixTodo != PrefixFormat.defaults["todo"]
+        case .match: prefixTags != PrefixFormat.defaults["tags"]
+        }
+    }
     @Environment(\.orgTheme) private var theme
     var body: some View {
             agenda.span = span
             agenda.startOffset = startOffset
             agenda.includeSubfolders = includeSubfolders
+            agenda.options.prefixFormat = ["agenda": prefixAgenda, "todo": prefixTodo, "tags": prefixTags]
+            agenda.options.logMode = logMode
             let open = session.openTexts
             await agenda.refresh(open: open)
         }
     @ViewBuilder
     private func rows(_ items: [AgendaItem], prefix: String, day: Int? = nil) -> some View {
         ForEach(Array(items.enumerated()), id: \.offset) { index, item in
-            AgendaRow(item: item, day: day)
+            AgendaRow(item: item, day: day, customPrefix: customPrefix)
                 .tag("\(prefix):\(index)")
                 .selectionDisabled(item.path == nil)
         }
         case "f" where isAgenda: agenda.shift(forward: true)
         case "b" where isAgenda: agenda.shift(forward: false)
         case "." where isAgenda: agenda.showToday()
+        case "l" where isAgenda:
+            logMode.toggle()
+            message = logMode ? "Log mode on" : "Log mode off"
         case "g", "r":
             loadViews()
             tick += 1
     let item: AgendaItem
     /// The agenda day the row is on, for habit graphs.
     var day: Int?
+    /// A user `org-agenda-prefix-format`: the prefix as Emacs prints it, not the columns.
+    var customPrefix = false
     @Environment(\.orgTheme) private var theme
     var body: some View {
             .font(.caption)
             .foregroundStyle(theme.color("agenda-today") ?? .accentColor)
         default:
+            if customPrefix {
+                HStack(spacing: 0) {
+                    Text(item.prefix)
+                        .font(.body.monospaced())
+                        .foregroundStyle(theme.color("agenda-category") ?? .secondary)
+                    title.lineLimit(1)
+                    Spacer(minLength: 8)
+                    if let habit = item.habit, let day { HabitGraph(cells: habit.graph(today: day), theme: theme) }
+                    if !item.tags.isEmpty {
+                        Text(":" + item.tags.joined(separator: ":") + ":").font(.caption).foregroundStyle(theme.color("tags") ?? .secondary)
+                    }
+                }
+            } else {
             HStack(spacing: 8) {
                 Text(item.category)
                     .lineLimit(1)
                         .foregroundStyle(theme.color("tags") ?? .secondary)
                 }
             }
+            }
         }
     }

Tests/OrgAppTests/EmacsImportTests.swift +4 −1

             org-tags-column -80))
     (setq org-tags-column 4)
     (setq org-log-done 'note org-log-into-drawer t)
+    (setq org-agenda-prefix-format '((agenda . " %i %-12:c%?-12t% s%b") (todo . " %-8:c")))
     (setq fill-column (+ 70 2))
     (setq org-capture-templates
           '(("t" "Todo" entry (file+headline "~/notes/todo.org" "Inbox") "* TODO %?\n%a")
         #expect(s["org-pretty-entities"] == .bool(true))
         #expect(s["org-log-done"] == .string("note"))
         #expect(s["org-log-into-drawer"] == .string("LOGBOOK"))
+        #expect(s["org-agenda-prefix-format.agenda"] == .string(" %i %-12:c%?-12t% s%b"))
+        #expect(s["org-agenda-prefix-format.todo"] == .string(" %-8:c"))
         // after! org runs after the top-level setq.
         #expect(s["org-tags-column"] == .integer(-80))
         #expect(s["org-agenda-span"] == .integer(10))
         let keymap = folder.appendingPathComponent("keymap.toml")
         #expect(KeymapLoader.load(.doom, userFile: keymap).problems.isEmpty)
         #expect(KeymapLoader.load(.doom, userFile: keymap).keymap.keyLabels(for: "app.agenda", modes: ["normal"]).contains("C-c a"))
-        #expect(summary.hasPrefix("Imported 14 settings, 3 capture templates, 3 key bindings."), "\(summary)")
+        #expect(summary.hasPrefix("Imported 16 settings, 3 capture templates, 3 key bindings."), "\(summary)")
         #expect(defaults.string(forKey: "themeFont") == "JetBrains Mono")
         #expect(defaults.integer(forKey: "themeFontSize") == 14)
     }

Tests/OrgCoreTests/AgendaTests.swift +98 −3

	@@ -107,12 +107,26 @@ enum AgendaOracle {
107	line.replacingOccurrences(of: "[ \\t]+(:[^ \\t]+:)[ \\t]*$", with: " $1", options: .regularExpression)	107	line.replacingOccurrences(of: "[ \\t]+(:[^ \\t]+:)[ \\t]*$", with: " $1", options: .regularExpression)
108	}	108	}
109		109
110	static func compare(files: [(name: String, text: String)], start: Int, span: Int, today: Int, hour: Int = 9, minute: Int = 30) throws {	110	/// `org-agenda-prefix-format` as Lisp.
		111	static func prefixLisp(_ formats: [String: String]) -> String {
		112	"'(" + formats.sorted { $0.key < $1.key }.map { "(\($0.key) . \"\($0.value)\")" }.joined(separator: " ") + ")"
		113	}
		114
		115	static func compare(
		116	files: [(name: String, text: String)], start: Int, span: Int, today: Int, hour: Int = 9, minute: Int = 30,
		117	prefix: [String: String]? = nil, logMode: Bool = false
		118	) throws {
111	let date = Days.date(start)	119	let date = Days.date(start)
112	let emacs = try run(files: files, form: "(org-agenda-list nil \"\(String(format: "%04d-%02d-%02d", date.year, date.month, date.day))\" \(span))", today: today, hour: hour, minute: minute)	120	var form = "(org-agenda-list nil \"\(String(format: "%04d-%02d-%02d", date.year, date.month, date.day))\" \(span))"
		121	if let prefix { form = "(let ((org-agenda-prefix-format \(prefixLisp(prefix)))) \(form))" }
		122	if logMode { form = "(let ((org-agenda-start-with-log-mode t)) \(form))" }
		123	let emacs = try run(files: files, form: form, today: today, hour: hour, minute: minute)
113	let defaults = OrgSettings.default.withTodoKeywords(keywords)!	124	let defaults = OrgSettings.default.withTodoKeywords(keywords)!
114	let sources = files.map { AgendaSource(path: $0.name, text: $0.text, defaults: defaults) }	125	let sources = files.map { AgendaSource(path: $0.name, text: $0.text, defaults: defaults) }
115	let ours = Agenda.list(sources, start: start, days: span, today: today, now: (hour, minute), options: .terminal)	126	var options = AgendaOptions.terminal
		127	if let prefix { options.prefixFormat = prefix }
		128	options.logMode = logMode
		129	let ours = Agenda.list(sources, start: start, days: span, today: today, now: (hour, minute), options: options)
116	#expect(ours.count == emacs.count)	130	#expect(ours.count == emacs.count)
117	for (o, e) in zip(ours, emacs) {	131	for (o, e) in zip(ours, emacs) {
118	#expect(o.header == e.header)	132	#expect(o.header == e.header)
	@@ -378,3 +392,84 @@ struct ReminderTests {
378	#expect(Set(reminders.map(\.id)).count == 6)	392	#expect(Set(reminders.map(\.id)).count == 6)
379	}	393	}
380	}	394	}
		395
		396	struct AgendaPrefixFormatTests {
		397	static let file = """
		398	#+TODO: TODO NEXT \| DONE
		399	* Projects [1/2] :proj:
		400	** TODO [#A] Write report :work:
		401	:PROPERTIES:
		402	:Effort: 1:30
		403	:END:
		404	SCHEDULED: <2026-10-05 Mon 10:00>
		405	*** NEXT Outline [[https://x.org][the plan]]
		406	DEADLINE: <2026-10-06 Tue>
		407	* Errands
		408	:PROPERTIES:
		409	:CATEGORY: averyverylongcategory
		410	:END:
		411	** TODO Groceries 14:00
		412	SCHEDULED: <2026-10-05 Mon>
		413	"""
		414
		415	static let formats = [
		416	"agenda": " %i %-12:c%?-12t%-6e% s%l%b", "todo": " %-8.6c %e %?-4l\|", "tags": "%c %?-5:l %b", "search": " %i %-12:c",
		417	]
		418
		419	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		420	func agendaMatchesEmacs() throws {
		421	let today = Days.absolute(year: 2026, month: 10, day: 5)
		422	try AgendaOracle.compare(files: [("p.org", Self.file)], start: today, span: 2, today: today, prefix: Self.formats)
		423	}
		424
		425	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		426	func listsMatchEmacs() throws {
		427	let today = Days.absolute(year: 2026, month: 10, day: 5)
		428	var options = AgendaOptions()
		429	options.prefixFormat = Self.formats
		430	let lisp = AgendaOracle.prefixLisp(Self.formats)
		431	try AgendaOracle.compareList(files: [("p.org", Self.file)], form: "(let ((org-agenda-prefix-format \(lisp))) (org-todo-list))", today: today) {
		432	Agenda.todoList($0, options: options)
		433	}
		434	try AgendaOracle.compareList(files: [("p.org", Self.file)], form: "(let ((org-agenda-prefix-format \(lisp))) (org-tags-view nil \"work\|proj\"))", today: today) {
		435	Agenda.tagsMatch($0, match: "work\|proj", options: options)
		436	}
		437	}
		438
		439	@Test func compilesFields() {
		440	let format = PrefixFormat(" %-8.6c\|%?-4t%e")
		441	#expect(format.render(["c": "category", "e": "1:00"]) == " categ \|1:00")
		442	#expect(format.render(["c": "cat", "t": "9:00"]) == " cat \|9:00")
		443	}
		444	}
		445
		446	struct AgendaLogModeTests {
		447	static let file = """
		448	#+TODO: TODO NEXT \| DONE
		449	* DONE Ship release :work:
		450	CLOSED: [2026-10-05 Mon 16:20] SCHEDULED: <2026-10-05 Mon>
		451	:LOGBOOK:
		452	CLOCK: [2026-10-05 Mon 14:00]--[2026-10-05 Mon 15:30] => 1:30
		453	- Fixed the build
		454	CLOCK: [2026-10-04 Sun 22:00]--[2026-10-05 Mon 01:15] => 3:15
		455	:END:
		456	* TODO Writing
		457	:LOGBOOK:
		458	CLOCK: [2026-10-06 Tue 09:00]--[2026-10-06 Tue 09:45] => 0:45
		459	CLOCK: [2026-10-06 Tue 11:00]
		460	:END:
		461	** DONE Draft [1/1]
		462	CLOSED: [2026-10-06 Tue]
		463	* Archived :ARCHIVE:
		464	CLOSED: [2026-10-05 Mon 10:00]
		465	* Plain
		466	Mentions CLOSED: [2026-10-05 Mon 09:00] in text.
		467	"""
		468
		469	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		470	func logModeMatchesEmacs() throws {
		471	let today = Days.absolute(year: 2026, month: 10, day: 5)
		472	try AgendaOracle.compare(files: [("log.org", Self.file)], start: today - 1, span: 3, today: today, logMode: true)
		473	try AgendaOracle.compare(files: [("log.org", Self.file)], start: today - 1, span: 3, today: today, prefix: ["agenda": " %-8:c%?-12t%s %l"], logMode: true)
		474	}
		475	}