Start timer opens its saved child immediately; every completed round requests a short chime and stronger haptic feedback.
Three fresh full-diff local reviews (reuse, quality, efficiency) found no material source defects. Both branches remain clean and unchanged draft PRs.
Correction: the pre-push-review skill does not require an external Claude call. A globally installed CLI was mistaken for a Meddy-specific reviewer. No repository reviewer configuration or GitHub integration was found. The directly approved CLI attempt exited during MCP configuration validation with no review result; further external calls are paused.
Ready to push
Fresh source reviews have no material findings. Saved native evidence contains 189 phone domain, 14 Watch domain and 11 full UI passes with completed commands. The full UI inventory matches all declared cases and its bundle is finalized. Domain evidence predates a whitespace-only adapter correction; the full UI build/run used committed bytes. Changed-adapter lint and whitespace pass. No required external reviewer is missing; physical feedback remains unverified.
34ec7e9c98fdff7c4238def53b1296969323095a [feat]: improve routine timer navigation and feedback (T2425, T2426) Start timer now takes you straight to that timer. Finished rounds request a short chime and a longer buzz.
You need one fewer navigation tap, and round completion is easier to notice.
Your saved timer stays the same when you return. Device settings can silence sound or haptics.
A local navigation destination opens the existing child returned after its successful save. The common completion adapter adds bundled PCM audio and platform-native haptics.
iPhone uses two continuous pulses over1.3 seconds. Watch uses two notification pulses0.7 seconds apart. Timer notifications use the same chime. Existing completion services remain responsible for once-per-round delivery.
Background phone vibration is system-controlled. No critical-alert entitlement or background audio mode is added.
beginTimedStep preserves canonical child identity and frozen profile/session ownership. Navigation does not issue a timer transition. Foreground feedback still follows durable completedRounds progression, not view observation; background catch-up remains suppressed.
The synchronized Shared group includes the adapter and resource in both apps. AVAudioPlayer loads lazily, ambient audio respects silent mode, Core Haptics has automatic shutdown and fallback, and Watch retains one cancellable delayed pulse.
Native tests cover child/pause retention, notification resource and sound, foreground suppression, ownership and each round including the final one. The later full UI command exits successfully with all eleven declared cases passing and a finalized result bundle. Earlier interrupted evidence is retained but superseded for the current UI gate. No physical installation occurred.
Meddy/Meddy/Features/RoutineRunView.swift
Why it matters. Removes the second navigation tap while retaining saved state.
What to look at. timerDestination / stepAction
Meddy/Shared/RoutineExecution/RoundCompletionFeedback.swift
Why it matters. Makes every completed round easier to notice.
What to look at. play / playChime / playPhoneHaptics
Meddy/Meddy/Services/ReminderService.swift
Why it matters. Keeps timer sound consistent while preserving OS-controlled delivery.
What to look at. add timer payload
Opening a child is navigation only. No automatic next round, treatment or medication action is introduced.
Ambient audio and standard Watch notification haptics provide feedback without bypassing silent mode or introducing critical-alert/background modes.
Source: local run at 2026-10-07T00:06:34.768967+00:00 · snapshot 34ec7e9c98fdff7c4238def53b1296969323095a
Baseline: none
Execution: passed · JUnit: 3 files · Coverage: none · Baseline: absent
Coverage scope: as the project configures it
Totals: 214 passed · 0 failed · 0 skipped · 0 errored · 0 flaky
Derived by declaration name, from the diff (no baseline run).
Files that import a changed file on the left, changed files in the centre, files a changed file imports on the right. Snapshot working-tree against base bcba6d9c71b0ce3770f101dabb9ffd99f1758d0e.
14 files: 11 code · 3 docs. Click to expand.
diff --git a/Meddy/Meddy/App/AppRootView.swift b/Meddy/Meddy/App/AppRootView.swiftindex a85ebe4..2e0c2bd 100644--- a/Meddy/Meddy/App/AppRootView.swift+++ b/Meddy/Meddy/App/AppRootView.swift@@ -60,6 +60,14 @@ struct AppRootView: View { navigation.start(routine, occurrence: nil) } catch { navigation.error = error.localizedDescription } }+ if AppEnvironment.isTesting, ProcessInfo.processInfo.environment["MEDDY_TEST_ORDERED_TIMER"] == "1" {+ do {+ let service = RoutineService(context: container.mainContext)+ let timer = try service.createTimed(name: "Synthetic saved timer", rounds: 2, durationSeconds: 60)+ let group = try service.createOrdered(name: "Synthetic timer group", steps: [.init(kind: .timedRoutine, targetID: timer.id)])+ navigation.start(group, occurrence: nil)+ } catch { navigation.error = error.localizedDescription }+ } #endif } .onChange(of: scenePhase) { _, phase in roundAlerts.setActive(phase == .active); if phase == .active { reminders?.refresh(); companion?.publish(); cloud.refresh() } }
diff --git a/Meddy/Meddy/Features/RoutineRunView.swift b/Meddy/Meddy/Features/RoutineRunView.swiftindex 3943d6b..fcf4ea9 100644--- a/Meddy/Meddy/Features/RoutineRunView.swift+++ b/Meddy/Meddy/Features/RoutineRunView.swift@@ -20,6 +20,7 @@ struct RoutineRunView: View { @State private var correctingTreatment: TreatmentCompletion? @State private var correctingMedication: Administration? @State private var linkingStep: FrozenRoutineStep?+ @State private var timerDestination: RoutineRun? @State private var endConfirmation = false private var service: RoutineSessionService { RoutineSessionService(context: context) } private var definition: FrozenRoutineDefinition? { try? service.definition(run) }@@ -34,6 +35,7 @@ struct RoutineRunView: View { } else { ContentUnavailableView("Saved plan needs review", systemImage: "exclamationmark.triangle", description: Text("The session could not be read. No action has been recorded.")) } } .navigationTitle(definition?.name ?? "Saved session")+ .navigationDestination(item: $timerDestination) { TimerRunView(run: $0) } .onAppear { perform { try service.reconcile(run) } } .sheet(item: $correctingTreatment) { TreatmentCompletionEditor(event: $0) } .sheet(item: $correctingMedication) { event in if let medication = event.medication { AdministrationEditor(medication: medication, event: event) } }@@ -124,7 +126,7 @@ struct RoutineRunView: View { if let childID = state.canonicalEventID, let child = runs.first(where: { $0.id == childID }) { NavigationLink("Open saved timer") { TimerRunView(run: child) } } else {- Button("Start timer") { perform { _ = try service.beginTimedStep(run, stepID: step.id) } }.buttonStyle(.borderedProminent)+ Button("Start timer") { perform { timerDestination = try service.beginTimedStep(run, stepID: step.id) } }.buttonStyle(.borderedProminent) } } }@@ -256,7 +258,7 @@ struct TimerRunView: View { if await center.notificationSettings().authorizationStatus == .notDetermined { do { let granted = try await center.requestAuthorization(options: [.alert, .sound])- if !granted { error = "Notifications are unavailable. Keep Meddy open for the round-completion buzz. Locked/background alerts require notification permission and iPhone sound/haptic settings." }+ if !granted { error = "Notifications are unavailable. Keep Meddy open for round-completion feedback. Sound and haptics depend on device settings; locked/background alerts also require notification permission." } } catch { self.error = error.localizedDescription } } MutationEffects.saved(context)
diff --git a/Meddy/Meddy/Services/PhoneRoundAlertService.swift b/Meddy/Meddy/Services/PhoneRoundAlertService.swiftindex a370761..36228c6 100644--- a/Meddy/Meddy/Services/PhoneRoundAlertService.swift+++ b/Meddy/Meddy/Services/PhoneRoundAlertService.swift@@ -53,9 +53,10 @@ final class PhoneRoundAlertService { keepAwake: ((Bool) -> Void)? = nil, enabled: Bool = true) { self.context = context; self.clock = clock self.scheduler = scheduler ?? SystemRoundDeadlineScheduler()+ let completionFeedback = RoundCompletionFeedback() self.feedback = feedback ?? { guard !AppEnvironment.isTesting else { return }- let generator = UINotificationFeedbackGenerator(); generator.prepare(); generator.notificationOccurred(.success)+ completionFeedback.play() } self.keepAwake = keepAwake ?? { if !AppEnvironment.isTesting { UIApplication.shared.isIdleTimerDisabled = $0 } } self.enabled = enabled
diff --git a/Meddy/Meddy/Services/ReminderService.swift b/Meddy/Meddy/Services/ReminderService.swiftindex 8ec501f..9a1ce74 100644--- a/Meddy/Meddy/Services/ReminderService.swift+++ b/Meddy/Meddy/Services/ReminderService.swift@@ -257,7 +257,9 @@ final class ReminderService: NSObject, UNUserNotificationCenterDelegate { switch reminder.payload { case .medication: content.categoryIdentifier = "MEDICATION" case .routine: content.categoryIdentifier = "ROUTINE"- case .timer: content.categoryIdentifier = "TIMER"+ case .timer:+ content.categoryIdentifier = "TIMER"+ content.sound = UNNotificationSound(named: UNNotificationSoundName(RoundCompletionFeedback.soundName)) case .followup: content.categoryIdentifier = "FOLLOWUP" } let trigger = UNTimeIntervalNotificationTrigger(timeInterval: max(isFollowup ? 0.001 : 1, reminder.deliveryAt.timeIntervalSince(clock())), repeats: false)
diff --git a/Meddy/MeddyTests/MeddyPhoneRoundAlertTests.swift b/Meddy/MeddyTests/MeddyPhoneRoundAlertTests.swiftindex bbc4e0d..6ec3adf 100644--- a/Meddy/MeddyTests/MeddyPhoneRoundAlertTests.swift+++ b/Meddy/MeddyTests/MeddyPhoneRoundAlertTests.swift@@ -1,6 +1,7 @@ import Foundation import SwiftData import Testing+import AVFAudio @testable import Meddy @MainActor@@ -11,6 +12,31 @@ struct MeddyPhoneRoundAlertTests { let service = RoutineSessionService(context: store.mainContext) return (store, try service.start(routine), service) }+ @Test func completionChimeIsBundledAndShortEnoughForSystemNotifications() throws {+ let url = try #require(Bundle.main.url(forResource: "RoundComplete", withExtension: "wav"))+ let player = try AVAudioPlayer(contentsOf: url)+ #expect(player.duration > 0.5 && player.duration < 2)+ }+ @Test func reopeningTimedStepReusesSameOwnedChildAndPausedCheckpoint() throws {+ let store = try AppEnvironment.makeContainer(isolated: true)+ let routines = RoutineService(context: store.mainContext)+ let timer = try routines.createTimed(name: "Synthetic child", rounds: 2, durationSeconds: 60)+ let group = try routines.createOrdered(name: "Synthetic parent", steps: [.init(kind: .timedRoutine, targetID: timer.id)])+ let service = RoutineSessionService(context: store.mainContext)+ let parent = try service.start(group, deviceID: "synthetic-phone")+ let stepID = try #require(service.definition(parent).steps.first?.id)+ let child = try service.beginTimedStep(parent, stepID: stepID)+ let start = ClockSample(wall: Date(), monotonic: 100, continuityID: "synthetic")+ try service.changeTimer(child, actionID: UUID(), clock: start, operation: .start)+ let pause = ClockSample(wall: start.wall.addingTimeInterval(5), monotonic: 105, continuityID: "synthetic")+ try service.changeTimer(child, actionID: UUID(), clock: pause, operation: .pause)+ let saved = try service.timer(child)+ let reopened = try service.beginTimedStep(parent, stepID: stepID)+ #expect(reopened.id == child.id && reopened.parentRoutineRunID == parent.id)+ #expect(reopened.profileID == parent.profileID && reopened.executionDeviceID == parent.executionDeviceID)+ #expect(try service.timer(reopened) == saved && saved.phase == .paused)+ #expect(try store.mainContext.fetchCount(FetchDescriptor<RoutineRun>()) == 2)+ } @Test func deadlineBuzzesEachRoundOnceWithoutAnyTimerViewAndNeverAutoStartsNext() throws { let (store, run, service) = try fixture(); let scheduler = SyntheticDeadlineScheduler() var sample = ClockSample(wall: Date(), monotonic: 100, continuityID: "synthetic"); var buzzes = 0; var awake = false
diff --git a/Meddy/MeddyTests/MeddyReminderServiceTests.swift b/Meddy/MeddyTests/MeddyReminderServiceTests.swiftindex 95e771c..7edab02 100644--- a/Meddy/MeddyTests/MeddyReminderServiceTests.swift+++ b/Meddy/MeddyTests/MeddyReminderServiceTests.swift@@ -6,6 +6,21 @@ import Testing @MainActor struct MeddyReminderServiceTests {+ @Test func timerNotificationUsesCompletionChimeWithoutForegroundDuplicate() async throws {+ let store = try AppEnvironment.makeContainer(isolated: true)+ let date = Date()+ let routine = try RoutineService(context: store.mainContext).createTimed(name: "Synthetic timer", rounds: 2, durationSeconds: 60)+ let service = RoutineSessionService(context: store.mainContext)+ let run = try service.start(routine)+ try service.changeTimer(run, actionID: UUID(), clock: .init(wall: date, monotonic: 100, continuityID: "synthetic"), operation: .start)+ let client = SyntheticReminderNotifications()+ let reminders = ReminderService(context: store.mainContext, notifications: client, registerDelegate: false, now: { date })+ reminders.refresh(); await reminders.waitForRefresh()+ let request = try #require(client.added.first(where: { $0.content.categoryIdentifier == "TIMER" }))+ #expect(request.content.sound == UNNotificationSound(named: UNNotificationSoundName("RoundComplete.wav")))+ #expect(ReminderService.foregroundPresentation(category: "TIMER").isEmpty)+ #expect(try service.timer(run).phase == .running)+ } @Test func staleTakenKeepsDeliveredDoseAndGenerationWithoutCreditingNewSchedule() throws { let store = try AppEnvironment.makeContainer(isolated: true) let records = MedicationService(context: store.mainContext)
diff --git a/Meddy/MeddyUITests/MeddyRoutineUITests.swift b/Meddy/MeddyUITests/MeddyRoutineUITests.swiftindex ccce1a6..a82c1f4 100644--- a/Meddy/MeddyUITests/MeddyRoutineUITests.swift+++ b/Meddy/MeddyUITests/MeddyRoutineUITests.swift@@ -47,7 +47,8 @@ final class MeddyRoutineUITests: XCTestCase { XCTAssertTrue(app.staticTexts["0 of 3 steps completed"].waitForExistence(timeout: 5), app.debugDescription) app.buttons["Done"].tap() app.buttons["Start timer"].tap()- app.buttons["Open saved timer"].tap()+ XCTAssertTrue(app.buttons["phoneTimerCircle"].waitForExistence(timeout: 5))+ XCTAssertEqual(app.buttons["phoneTimerCircle"].label, "Start round 1 of 1") app.buttons["phoneTimerCircle"].tap() XCTAssertTrue(app.staticTexts["1 rounds completed"].waitForExistence(timeout: 8)) app.navigationBars.buttons.element(boundBy: 0).tap()@@ -133,6 +134,33 @@ final class MeddyRoutineUITests: XCTestCase { XCTAssertEqual(circle.label, "Resume round 1 of 1") } + func testStartTimerOpensSavedChildAndPreservesPauseWhenReturning() {+ continueAfterFailure = false+ let app = XCUIApplication()+ app.launchEnvironment["MEDDY_TESTING"] = "1"+ app.launchEnvironment["MEDDY_TEST_ORDERED_TIMER"] = "1"+ app.launch()+ let start = app.buttons["Start timer"]+ XCTAssertTrue(start.waitForExistence(timeout: 5))+ start.tap()+ let circle = app.buttons["phoneTimerCircle"]+ XCTAssertTrue(circle.waitForExistence(timeout: 5))+ XCTAssertEqual(circle.label, "Start round 1 of 2")+ circle.tap()+ XCTAssertEqual(circle.label, "Pause round 1 of 2")+ circle.tap()+ XCTAssertEqual(circle.label, "Resume round 1 of 2")+ app.navigationBars.buttons.element(boundBy: 0).tap()+ let reopen = app.buttons["Open saved timer"]+ XCTAssertTrue(reopen.waitForExistence(timeout: 5))+ XCTAssertFalse(app.buttons["Start timer"].exists)+ reopen.tap()+ XCTAssertTrue(circle.waitForExistence(timeout: 5))+ XCTAssertEqual(circle.label, "Resume round 1 of 2")+ XCTAssertTrue((circle.value as? String)?.contains("remaining") == true)+ XCTAssertFalse(app.alerts.firstMatch.exists)+ }+ private func addCare(_ kind: String, in app: XCUIApplication) { app.buttons["Add care item"].tap() app.buttons[kind].tap()
diff --git a/Meddy/MeddyWatch/WatchController.swift b/Meddy/MeddyWatch/WatchController.swiftindex 0f96333..6556212 100644--- a/Meddy/MeddyWatch/WatchController.swift+++ b/Meddy/MeddyWatch/WatchController.swift@@ -31,7 +31,8 @@ final class WatchController { transportEnabled = activate && !testing runtimeEnabled = transportEnabled || runtime != nil self.runtime = runtime ?? RoundRuntime(); self.clock = clock- self.haptic = haptic ?? { if !testing { WKInterfaceDevice.current().play(.success) } }+ let completionFeedback = RoundCompletionFeedback()+ self.haptic = haptic ?? { if !testing { completionFeedback.play() } } do { let isolated = FileManager.default.temporaryDirectory.appendingPathComponent("MeddyTest-" + UUID().uuidString).appendingPathComponent("cache.json") let path = file ?? (testing ? isolated : FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0].appendingPathComponent("MeddyCompanion/cache.json"))
diff --git a/Meddy/MeddyWatchTests/MeddyWatchTests.swift b/Meddy/MeddyWatchTests/MeddyWatchTests.swiftindex a1edad1..6290eb0 100644--- a/Meddy/MeddyWatchTests/MeddyWatchTests.swift+++ b/Meddy/MeddyWatchTests/MeddyWatchTests.swift@@ -129,6 +129,26 @@ struct MeddyWatchTests { #expect(controller.value(id)?.timer?.phase == .ended && signals == 1) } + @Test func everyCompletedRoundSignalsOnceIncludingFinalBoundary() throws {+ let file = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathComponent("watch.json")+ defer { try? FileManager.default.removeItem(at: file.deletingLastPathComponent()) }+ let runtime = SyntheticRoundRuntime()+ var sample = ClockSample(wall: Date(), monotonic: 0, continuityID: "synthetic")+ var signals = 0+ let controller = WatchController(file: file, activate: false, runtime: runtime, clock: { sample }, haptic: { signals += 1 })+ let definition = FrozenRoutineDefinition(routineID: UUID(), revision: 1, kind: .timedRounds, name: "Synthetic timer", instructions: "", roundCount: 2, roundDurationSeconds: 10, betweenRoundInstructions: "", steps: [])+ let id = try controller.start(.init(definition: definition, occurrences: []), occurrence: nil)+ for round in 1...2 {+ try controller.transitionTimer(id, .start)+ sample.wall = sample.wall.addingTimeInterval(10); sample.monotonic += 10+ runtime.onBoundary(); runtime.onBoundary(); controller.tick()+ #expect(signals == round)+ #expect(controller.value(id)?.timer?.completedRounds == round)+ #expect(controller.value(id)?.timer?.phase == (round == 1 ? .waiting : .completed))+ }+ #expect(runtime.deadlines.count == 2)+ }+ }
diff --git a/Meddy/Shared/RoutineExecution/RoundComplete.wav b/Meddy/Shared/RoutineExecution/RoundComplete.wavnew file mode 100644index 0000000..18d029aBinary files /dev/null and b/Meddy/Shared/RoutineExecution/RoundComplete.wav differ
diff --git a/Meddy/Shared/RoutineExecution/RoundCompletionFeedback.swift b/Meddy/Shared/RoutineExecution/RoundCompletionFeedback.swiftnew file mode 100644index 0000000..0609416--- /dev/null+++ b/Meddy/Shared/RoutineExecution/RoundCompletionFeedback.swift@@ -0,0 +1,79 @@+import AVFAudio+import Foundation+#if os(iOS)+import CoreHaptics+import UIKit+#elseif os(watchOS)+import WatchKit+#endif++/// Called once by the saved round-boundary services, never by a timer view redraw.+/// Ambient audio respects silent mode/volume; hardware and OS policy govern haptics.+@MainActor+final class RoundCompletionFeedback {+ static let soundName = "RoundComplete.wav"+ private var audioPlayer: AVAudioPlayer?+ #if os(iOS)+ private var hapticEngine: CHHapticEngine?+ private var hapticPlayer: (any CHHapticPatternPlayer)?+ #elseif os(watchOS)+ private var secondPulse: Task<Void, Never>?+ #endif++ func play() {+ playChime()+ #if os(iOS)+ playPhoneHaptics()+ #elseif os(watchOS)+ secondPulse?.cancel()+ WKInterfaceDevice.current().play(.notification)+ secondPulse = Task { @MainActor in+ do { try await Task.sleep(for: .milliseconds(700)) } catch { return }+ WKInterfaceDevice.current().play(.notification)+ }+ #endif+ }++ private func playChime() {+ do {+ try AVAudioSession.sharedInstance().setCategory(.ambient)+ if audioPlayer == nil {+ guard let url = Bundle.main.url(forResource: "RoundComplete", withExtension: "wav") else { return }+ audioPlayer = try AVAudioPlayer(contentsOf: url)+ }+ audioPlayer?.currentTime = 0+ audioPlayer?.play()+ } catch {+ // Audio interruption/unavailability must not lose a completed round or its haptic.+ }+ }++ #if os(iOS)+ private func playPhoneHaptics() {+ guard CHHapticEngine.capabilitiesForHardware().supportsHaptics else { return }+ do {+ if hapticEngine == nil {+ let engine = try CHHapticEngine(audioSession: AVAudioSession.sharedInstance())+ engine.playsHapticsOnly = true+ engine.isAutoShutdownEnabled = true+ hapticEngine = engine+ }+ guard let engine = hapticEngine else { return }+ try engine.start()+ let parameters = [CHHapticEventParameter(parameterID: .hapticIntensity, value: 1),+ CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.3)]+ let pattern = try CHHapticPattern(events: [+ CHHapticEvent(eventType: .hapticContinuous, parameters: parameters, relativeTime: 0, duration: 0.45),+ CHHapticEvent(eventType: .hapticContinuous, parameters: parameters, relativeTime: 0.65, duration: 0.65)+ ], parameters: [])+ hapticPlayer = try engine.makePlayer(with: pattern)+ try hapticPlayer?.start(atTime: CHHapticTimeImmediate)+ } catch {+ hapticPlayer = nil+ hapticEngine = nil+ // Retain the former system success cue if a custom engine cannot run.+ UINotificationFeedbackGenerator().notificationOccurred(.success)+ }+ }+ #endif+}
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 167510a..9419447 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -3,11 +3,13 @@ ## Unreleased ### Fixed+- T2425: Open the saved child timer immediately after Start timer in an ordered routine, preserving its paused/resume state on return. - T2419: Remove redundant Done editing keyboard buttons from care editors, retaining scrolling and explicit Save/Cancel. - T2420: Simplify as-needed limits to quantity, interval and a 24-hour daily cap, with next-dose time and remaining allowance; retain older windows until explicitly converted. - T2413: Keep notification snoozes at their chosen 15-minute deadline, cancel queued originals, suppress elapsed replay and await background scheduling completion. ### Added+- T2426: Short completion chime and longer per-round feedback: a two-pulse iPhone haptic pattern and two Watch notification pulses, subject to device sound/haptic settings. - T2415: Background-callable Record Waking Up shortcut with stable profile selection and first-wake daily anchors; medication and ordered-session elapsed wake offsets with persistent no-replay reminder receipts. - T2414: Me and optional dependant profiles with separate care/history/PRN/export views, captured notification and Watch ownership, reversible archive/restore and a small additive startup transition. Restored saved sessions resume explicitly on iPhone before continuing on Watch. - Structured UTF-8 Markdown Current Medications export with purpose/medication headings, labelled fields, escaped multiline content and a dated .md share filename.
diff --git a/docs/meddy-design.md b/docs/meddy-design.mdindex 27ed4b4..d9cb9c0 100644--- a/docs/meddy-design.md+++ b/docs/meddy-design.md@@ -940,7 +940,7 @@ The current group can be built as `Clean eyes → Hot Compress → Ointment`, wi On iPhone and Watch, open a selected session into a compact ordered checklist with the current step prominent and subsequent steps visibly waiting. iPhone execution is required for completion and medication steps and for resume/history; provide the same clock-based timer engine on iPhone so the whole sequence can be completed there. Watch remains the priority for haptic timing. Do not leave iPhone Start as a placeholder that cannot execute the new workflow. - Treatment: instructions plus `Done`.-- Timed routine: `Start timer`, rounds, and explicit `Start next round`; final round completion finishes that step and reveals the next one. A phone background timer uses persisted deadlines and local completion notification when authorised; do not promise Watch-style extended runtime on iPhone.+- Timed routine: `Start timer` immediately opens that saved child timer; returning reuses the same child and checkpoint. The timer circle remains the explicit round start/pause/resume control. Rounds and explicit `Start next round`; final round completion finishes that step and reveals the next one. A phone background timer uses persisted deadlines and local completion notification when authorised; do not promise Watch-style extended runtime on iPhone. - Medication: frozen instructions/default dose plus `Taken`/`Applied`; one action records one administration. Dose not recorded remains valid. - `Pause`/`Resume`, `Skip step`, and `End session` are explicit secondary actions. Skip shows the omission and requires a separate `Continue with skipped step` choice before allowing downstream work. This is an accurate record of the user’s choice, not advice that skipping is medically safe. @@ -1097,7 +1097,7 @@ The timer must derive remaining time from a persisted deadline and accumulated a At exactly the configured round duration: -- play a clear Watch haptic+- play a short chime and more noticeable haptic feedback once per completed round, including the final round: two continuous iPhone pulses over 1.3 seconds, or two Watch notification pulses 0.7 seconds apart. Ambient audio respects silent mode/volume; hardware and OS settings govern delivery. Background iPhone delivery uses the same bundled chime in its authorised timer notification, with system-controlled vibration. - stop the timer - mark the round complete - invalidate that round's extended runtime session
diff --git a/docs/meddy-implementation-plan.md b/docs/meddy-implementation-plan.mdindex 01e9dd2..c03cc1b 100644--- a/docs/meddy-implementation-plan.md+++ b/docs/meddy-implementation-plan.md@@ -283,3 +283,12 @@ Legacy non-24-hour limits continue using their saved window with a small factual `SimpleDoseDomainFinal.xcresult` passed **37 tests in 4 focused suites** (PRN checks, profile routing, recording and editor transactions). Coverage includes no clinical-context/history requirement, fixed elapsed 24-hour expiry across 02:00/DST, fractional remaining quantities, both cap and interval determining the next time, exact legacy preservation/explicit conversion with recorded-dose identity/timestamp/quantity retention, canonical correction/Undo, other-medication/profile exclusion, unknown quantities/clocks, disk reload and old companion DTOs. `SimpleDoseUIAcceptance.xcresult` passed the **single dosage editor/Taken/Undo smoke in 40.616 seconds**, checking removed fields, saved limits, 7.5 → 6.5 remaining quantity, next-dose display and Undo restoration. The new test's initial throwing macro expression was corrected; stopped UI attempts exposed retained keyboard accessibility elements and background/clipped control targeting. Only the owned run/runner/app PIDs were stopped and drained; those overall runs are not counted as successful acceptance suites. The separate T2419 editor scenario passed before a later dosage-navigation interruption, as documented above. Simulator compilation and `git diff --check` passed. Existing non-failing SwiftUI publication and simulator accessibility warnings remain. No medical-safety claim or drug-specific limits are provided: status is “Fits your entered limits” and “Based on doses logged for this medication.” No phone/physical Watch installation, live store reset, account/capability changes, or real notification/CloudKit acceptance occurred.+++## T2425 / T2426 routine timer usability++Start timer now saves/returns the existing canonical timed child and immediately pushes its timer page. Leaving and reopening retains the same child, captured profile/execution owner and paused checkpoint; this navigation does not auto-start a round. Existing next-round and next-step actions remain explicit.++Completion services still emit once after durable completed-round progression, independent of view redraws. Their shared native adapter plays a bundled 0.85-second two-note PCM chime. iPhone uses two continuous Core Haptics pulses over 1.3 seconds, with the former success cue as an engine-error fallback; Watch uses two system notification pulses 0.7 seconds apart. Audio uses the ambient category and does not bypass silent mode/volume. Authorised background iPhone timer notifications use the same chime; background vibration remains under OS control. No new background mode, permission, signing or entitlement is introduced. Physical Watch delivery is not inferred from simulator results.++Verification in the isolated feature branch from `bcba6d9`: phone domain tests passed **189 tests in 26 suites**, Watch domain/controller tests passed **14 tests in two suites**, and the new adapter passed strict SwiftLint after one formatting correction. Both app targets compiled, with the baseline `WKExtension` deprecation and App Intents metadata warnings retained. The targeted immediate-navigation/pause/back/reopen UI case logged one pass in **16.164 seconds**, but the overall command did not exit before its separate **300-second deadline** and was terminated. This is incomplete UI gate evidence, consistent with the independently observed shared XCTest runner completion/teardown blocker; no equivalent retry or full UI suite was run. Assigned simulators were shut down and exact owned process groups were confirmed absent. Three source reviewers found no material issues. The reviewed source is preserved in a local feature-branch commit with this UI-finalization limitation recorded. Push and draft PR publication remain held pending a completed applicable gate. Deployment awaits the user's explicit reply; no installation has occurred.
Existing native evidence is reused; no new builds or simulator tests ran. The Swift ecosystem registry has no runner for this Xcode project. Native test trees were converted to JUnit; no coverage was collected.