Commit `2bdd22c60b`

2bdd22c60b247fc90332f15b31c0b4fdc3c36c0e

parent: 24b5036e3f

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-09 01:11 UTC

Resolve dangling clocks on agenda and capture clock-in

org-agenda-clock-in and a template's :clock-in both run org-clock-in, which resolves open clocks when no clock is running. The agenda (Mac and iOS) and capture now clock in through the same path as Clock In, asking in the echo area or the clock sheet; capture resolves as of when capture began.

Layout: unified · split

Sources/OrgApp/ClockModel.swift +31 −12

         }
     }
-    /// A template's `clock-in` once its entry is filed: clocked from when capture began and,
+    /// A template's `clock-in` once its entry is filed: `org-clock-in` at the entry as when
-    /// without `clock-keep`, clocked out now, the clock it interrupted resuming with
+    /// capture began, dangling clocks resolved first, and, without `clock-keep`, clocked out
-    /// `clock-resume`. The messages, in order.
+    /// now, the clock it interrupted resuming with `clock-resume`.
     public func captured(
-        _ entry: (path: String, offset: Int), options: CaptureTemplate.Options, session: DocumentSession, opened: Date, now: Date = Date()
+        _ entry: (path: String, offset: Int), options: CaptureTemplate.Options, session: DocumentSession, paths: [String], ask: Ask,
-    ) -> [String] {
+        opened: Date, now: Date = Date()
-        guard options.clockIn else { return [] }
+    ) async -> Outcome {
-        let previous = self.entry(session)
+        guard options.clockIn else { return Outcome() }
-        var messages = [clockIn(session, path: entry.path, at: entry.offset, now: opened)]
+        let previous = running == nil ? nil : runningTask(session)
+        var outcome = await clockIn(session, target: .entry(path: entry.path, offset: entry.offset), paths: paths, ask: ask, now: { opened })
         if !options.clockKeep {
-            messages.append(clockOut(session, now: now))
+            outcome.messages.append(clockOut(session, now: now))
             if options.clockResume, let previous {
-                messages.append(clockIn(session, path: previous.path, at: previous.offset, now: now))
+                let resumed = await clockIn(session, target: .task(previous), paths: paths, ask: ask, now: { now })
+                outcome.messages += resumed.messages
+                if let jump = resumed.jump { outcome.jump = jump }
             }
         }
-        return messages
+        return outcome
     }
     static func text(_ path: String, _ session: DocumentSession) -> String? {
         case last
         /// A remembered entry.
         case task(ClockTask)
+        /// The heading containing `offset` in `path` (the agenda's `org-agenda-clock-in`, a
+        /// capture template's `clock-in`).
+        case entry(path: String, offset: Int)
     }
     /// `org-clock-in` as a command: dangling clocks in `paths` are resolved first when no
             outcome.messages.append("No last clock")
             return outcome
         }
+        var target = target
+        // Resolving may edit the entry's file, so its heading is found again afterwards.
+        if case .entry(let path, let offset) = target {
+            guard let text = Self.text(path, session) else {
+                outcome.messages.append("Can't read \(path)")
+                return outcome
+            }
+            guard let task = ClockTask.at(offset, in: text, path: path) else {
+                outcome.messages.append("Before first headline")
+                return outcome
+            }
+            target = .task(task)
+        }
         let wasRunning = running != nil
         let stopped = leftover
         if !wasRunning {
                 }
                 location = found
             }
-        case .last, .task:
+        case .last, .task, .entry:
             let task: ClockTask
             if case .task(let chosen) = target { task = chosen } else { task = history[0] }
             guard let found = locate(task, session) else {

Sources/Orgstar/AgendaView.swift +7 −2

             message = "No entry selected"
             return
         }
-        message = clock.clockIn(session, path: entry.path, at: offset)
+        let paths = workspace.files.filter { $0.kind == .org }.map(\.path)
-        tick += 1
+        Task {
+            let outcome = await clock.clockIn(session, target: .entry(path: entry.path, offset: offset), paths: paths, ask: commands.askClock)
+            if let jump = outcome.jump { commands.jump(path: jump.path, offset: jump.offset) }
+            message = outcome.messages.last { !$0.isEmpty }
+            tick += 1
+        }
     }
     private func archive() {

Sources/Orgstar/CaptureView.swift +10 −2

         case .success(let entry):
             commands.show("Captured to \(Self.target(template))")
             let options = template.options
-            for message in clock.captured(entry, options: options, session: session, opened: opened, now: now) { commands.show(message) }
+            let paths = workspace.files.filter { $0.kind == .org }.map(\.path)
-            if options.jumpToCaptured { commands.jump(path: entry.path, offset: entry.offset) }
+            Task { [commands, clock, session] in
+                let outcome = await clock.captured(entry, options: options, session: session, paths: paths, ask: commands.askClock, opened: opened, now: now)
+                for message in outcome.messages { commands.show(message) }
+                if let jump = outcome.jump {
+                    commands.jump(path: jump.path, offset: jump.offset)
+                } else if options.jumpToCaptured {
+                    commands.jump(path: entry.path, offset: entry.offset)
+                }
+            }
         }
         close()
     }

Sources/Orgstar/ContentView.swift +1 −8

         }
     }
-    /// Clock questions in the echo area.
+    private var askClock: ClockModel.Ask { commands.askClock }
-    private var askClock: ClockModel.Ask {
-        { [commands] prompt in
-            await withCheckedContinuation { continuation in
-                commands.ask(prompt) { continuation.resume(returning: $0) }
-            }
-        }
-    }
     /// The files `org-resolve-clocks` looks through: the workspace's org files.
     private var orgFiles: [String] { workspace.files.filter { $0.kind == .org }.map(\.path) }

Sources/Orgstar/OrgstarApp.swift +9

	@@ -62,6 +62,15 @@ final class AppCommands {
62	self.prompt = PromptRequest(prompt: prompt, reply: reply)	62	self.prompt = PromptRequest(prompt: prompt, reply: reply)
63	}	63	}
64		64
		65	/// Clock questions in the echo area.
		66	var askClock: ClockModel.Ask {
		67	{ [self] prompt in
		68	await withCheckedContinuation { continuation in
		69	ask(prompt) { continuation.resume(returning: $0) }
		70	}
		71	}
		72	}
		73
65	/// Ends the prompt with an answer, or nil to cancel, and gives the editor the keys back.	74	/// Ends the prompt with an answer, or nil to cancel, and gives the editor the keys back.
66	func answer(_ text: String?) {	75	func answer(_ text: String?) {
67	guard let request = prompt else { return }	76	guard let request = prompt else { return }

Sources/OrgstarMobile/AgendaScreen.swift +12 −1

     let scheduler: ReminderScheduler
     @State private var message: String?
     @Environment(ClockModel.self) private var clock
+    @Environment(MobileModel.self) private var model
     @State private var tick = 0
     @State private var views = AgendaViewLoader.builtIn
     @State private var viewName = "Agenda"
                 Button("Tags…", systemImage: "tag") { run("org.tags.set", on: item) }
                 Button("Priority…", systemImage: "exclamationmark.circle") { run("org.priority.set", on: item) }
                 Button("Clock In", systemImage: "stopwatch") {
-                    if let (path, offset) = locate(item) { message = clock.clockIn(session, path: path, at: offset) }
+                    if let (path, offset) = locate(item) { clockIn(path, offset) }
                 }
                 Divider()
                 Button("Refile…", systemImage: "arrow.turn.down.right") { refiling = item }
         return (path, offset)
     }
+    /// `org-agenda-clock-in`: `org-clock-in` at the entry, dangling clocks resolved first.
+    private func clockIn(_ path: String, _ offset: Int) {
+        let paths = workspace.files.filter { $0.kind == .org }.map(\.path)
+        Task {
+            let outcome = await clock.clockIn(session, target: .entry(path: path, offset: offset), paths: paths, ask: model.clockPrompts.ask)
+            if let jump = outcome.jump { model.openRequest = .offset(jump.path, jump.offset) }
+            message = outcome.messages.last { !$0.isEmpty }
+        }
+    }
     /// Runs a command at the entry's heading, asking what it asks.
     private func run(_ id: String, on item: AgendaItem, answers: [String: String] = [:]) {
         guard let command = Commands.command(id) else { return }

Sources/OrgstarMobile/CaptureScreen.swift +4 −1

             editing = true
         case .success(let entry):
             // Clocked from when capture began.
-            _ = clock.captured(entry, options: template.options, session: session, opened: context.now, now: now)
+            let paths = workspace.files.filter { $0.kind == .org }.map(\.path)
+            Task { [clock, session, opened = context.now] in
+                _ = await clock.captured(entry, options: template.options, session: session, paths: paths, ask: model.clockPrompts.ask, opened: opened, now: now)
+            }
             if template.options.jumpToCaptured { model.openRequest = .offset(entry.path, entry.offset) }
             dismiss()
         }

Tests/OrgAppTests/ClockHistoryModelTests.swift +53

	@@ -111,6 +111,59 @@ struct ClockHistoryModelTests {
111	#expect(clock.leftover == nil)	111	#expect(clock.leftover == nil)
112	}	112	}
113		113
		114	/// `org-agenda-clock-in` runs `org-clock-in` at the entry, so it resolves first too, and
		115	/// finds the entry after resolving moved it.
		116	@Test func clockingInAtAnEntryResolvesDanglingClocks() async throws {
		117	let other = try notes.write("other.org", "* Old\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 09:00]\n:END:\n* New\n")
		118	let clock = ClockModel(file: stateFile, defaults: defaults)
		119	let started = clock.openClocks(session, paths: [other.path])[0].startedAt
		120	let text = try #require(ClockModel.text(other.path, session))
		121	let entry = (text as NSString).range(of: "* New").location
		122	let answers = ScriptedAnswers(["K", "30"])
		123	let outcome = await clock.clockIn(
		124	session, target: .entry(path: other.path, offset: entry), paths: [other.path], ask: answers.ask, now: { started.addingTimeInterval(7200) }
		125	)
		126	#expect(answers.asked.first == "Dangling clock started 120 mins ago" + ClockResolution.keyHint)
		127	#expect(clock.running?.heading == "New" && outcome.messages.last == "Clock starts at [2026-09-09 Wed 11:00]")
		128	let updated = try #require(ClockModel.text(other.path, session))
		129	#expect(
		130	updated == "* Old\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 09:00]--[2026-09-09 Wed 09:30] => 0:30\n:END:\n* New\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 11:00]\n:END:\n",
		131	"\(updated)"
		132	)
		133	}
		134
		135	/// A template's `clock-in` is `org-clock-in` when capture began: dangling clocks are
		136	/// resolved as of then, and the entry is clocked out when it is filed.
		137	@Test func captureClockInResolvesDanglingClocks() async throws {
		138	let other = try notes.write("other.org", "* Old\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 09:00]\n:END:\n")
		139	let clock = ClockModel(file: stateFile, defaults: defaults)
		140	let opened = clock.openClocks(session, paths: [other.path])[0].startedAt.addingTimeInterval(7200)
		141	let answers = ScriptedAnswers(["K", "30"])
		142	let outcome = await clock.captured(
		143	(work.path, offset("* C")), options: .init(clockIn: true), session: session, paths: [other.path], ask: answers.ask,
		144	opened: opened, now: opened.addingTimeInterval(600)
		145	)
		146	#expect(answers.asked.first == "Dangling clock started 120 mins ago" + ClockResolution.keyHint)
		147	#expect(outcome.messages.suffix(2) == ["Clock starts at [2026-09-09 Wed 11:00]", "Clock stopped after 0:10"])
		148	#expect(clock.running == nil && clock.history.first?.title == "C")
		149	#expect(try #require(ClockModel.text(other.path, session)).contains("=> 0:30"))
		150	}
		151
		152	/// With a clock running the capture clock-in resolves nothing; the `clock-resume` clock-in,
		153	/// with no clock running, does, as in Org.
		154	@Test func captureClockInResumesTheInterruptedClock() async throws {
		155	let other = try notes.write("other.org", "* Old\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 09:00]\n:END:\n")
		156	let clock = ClockModel(file: stateFile, defaults: defaults)
		157	_ = clock.clockIn(session, path: work.path, at: offset("* A"), now: start)
		158	let answers = ScriptedAnswers([])
		159	let outcome = await clock.captured(
		160	(work.path, offset("* C")), options: .init(clockIn: true, clockResume: true), session: session, paths: [other.path],
		161	ask: answers.ask, opened: start.addingTimeInterval(600), now: start.addingTimeInterval(900)
		162	)
		163	#expect(answers.asked.count == 1 && answers.asked[0].hasPrefix("Dangling clock started"))
		164	#expect(outcome.messages.count == 3 && clock.running?.heading == "A")
		165	}
		166
114	@Test func jumpingFromADanglingClockShowsItAfterClockingIn() async throws {	167	@Test func jumpingFromADanglingClockShowsItAfterClockingIn() async throws {
115	let other = try notes.write("other.org", "* Old\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 09:00]\n:END:\n")	168	let other = try notes.write("other.org", "* Old\n:LOGBOOK:\nCLOCK: [2026-09-09 Wed 09:00]\n:END:\n")
116	let clock = ClockModel(file: stateFile, defaults: defaults)	169	let clock = ClockModel(file: stateFile, defaults: defaults)

Commit 2bdd22c60b

Commit `2bdd22c60b`