project · macos · swift
Tick-Tock for Mac — recording the meetings you attended, without ever hearing one
A menu-bar app that writes the calls you actually took onto your calendar, by watching which application is holding the microphone. It never records audio — and it never asks for microphone permission, because it has no way to use one.
My calendar is a record of meetings that were scheduled. It is a poor record of meetings that happened. The half of my week that lives in ad-hoc Slack huddles leaves no trace at all, and the half that was scheduled includes things I declined, missed, or left after four minutes.
So: reconstruct the day from signals the machine already emits, and let a human confirm the result. Same premise as the Android app of the same name. On a phone the richest signals are notifications, call logs and geofences. On a Mac there is one that beats all of them — which application is holding the microphone. Nothing else so cleanly separates "I was in a call" from "I had Zoom open".
It has since grown two things that are not about microphones at all: a detected meeting can be logged to Toggl Track as well as written to a calendar, and the day's note lives in Notion, opened from a screen corner and edited in the app. Both are further down, and both turned out to be more interesting than the feature descriptions suggest — one because of a three-valued answer collapsed into a boolean, the other because macOS will not let an app have a hot corner.
It never records audio, and could not if it wanted to
This is the first thing to establish, because "an app that knows when you are in meetings" sounds exactly like an app that is listening.
Detection reads a CoreAudio property that describes which processes currently hold the microphone. That is metadata about the audio system, not audio. There is no capture code in the app, no NSMicrophoneUsageDescription in the bundle, and consequently no microphone prompt — macOS never offers the grant because the app never asks, and it could not use it if granted.
The distinction is worth stating precisely: the app knows Zoom held the microphone from 14:02 to 14:47. It does not know, and has no mechanism to learn, a single word that was said.
The cost is a hard floor of macOS 14.4. Per-application microphone attribution comes from CoreAudio process objects, which do not exist before that release, and there is no degraded fallback — an earlier macOS can tell you the microphone is in use but not by whom, which is precisely the part that matters. It also cannot run headless or in CI: detection reads the local audio process list and needs permissions that only exist for a logged-in user on a real Mac.
You can check the claim rather than take it, which is the only reason it is worth making. The shipped bundle declares two usage descriptions and no third:
NSCalendarsUsageDescription = …adds an event for each meeting it detects…
NSAppleEventsUsageDescription = …checks whether your browser has a Meet call open…
LSMinimumSystemVersion = 14.4
LSUIElement = true
# and the one that is absent:
NSMicrophoneUsageDescription — not present
An app with no microphone usage description cannot be granted microphone access by macOS at all. The privacy claim is enforced by the platform, not by my good intentions.
The microphone was never the hard part
Watching CoreAudio turned out to be about 200 lines against a well-behaved API. The actual problem is deciding which microphone activity constitutes a meeting, and every rule in that decision is a threshold or an ordering question over timestamps:
- A mute toggle must not split one call into two events.
- A two-second microphone grab must not reach the calendar.
- Two genuinely separate back-to-back calls must not merge into one.
- A dictation burst during a call must not fragment or corrupt that call.
- A three-hour call must not be cut short.
- A clock moving backwards must not produce an event that ends before it begins.
The obvious implementation — a class that reads Date(), holds mutable state, and mutates it from CoreAudio listener callbacks — makes every one of those verifiable only by sitting through real meetings and waiting. The project's own risk assessment had already named the real microphone signal as its top risk, meaning those thresholds were expected to need repeated retuning against observed data. At a day per retuning cycle, that is not a design, it is a sentence.
So SessionEngine is a pure value type. Its inputs are immutable snapshots that carry their own timestamp; its outputs are sessions. It performs no I/O, reads no clock, and imports nothing from CoreAudio, the journal, the calendar writer or EventKit. Completion-by-elapsed-time is an explicit flushExpired(at:) call rather than an internal timer.
The part I would defend hardest is the enforcement mechanism, which is one line of Package.swift:
// SessionEngine depends on Support and NOTHING else. Ever.
.target(name: "SessionEngine", dependencies: ["Support"]),
Reaching for the clock inside the engine is therefore a compile error rather than a review comment. A clock protocol injected into an impure engine was the obvious middle road and I rejected it: it leaves the door open to the engine acquiring I/O later, and the whole test strategy rests on that door being shut. The dependency edge is what makes the guarantee durable instead of aspirational — the ADR recording it exists mostly so that a future me, who will find adding Date() there entirely harmless-looking, is told otherwise.
The payoff is the whole rule set exercised over synthetic timelines that would take hours to live through:
✔ Test "a mute toggle does not split one call into two events" passed
✔ Test "draining twice does not write the same session twice" passed
✔ Test "a pending session is written on the next startup, not duplicated" passed
✔ Suite "Journal-before-calendar ordering (AC7)" passed
✔ Test run with 1044 tests in 199 suites passed after 0.992 seconds
The concurrency case that worried me most — a dictation tool interleaving through a 30-minute huddle — is six function calls. Retuning a threshold means editing one struct and rerunning the suite. 14,100 lines of tests against 20,900 lines of source is a ratio I would normally be suspicious of; here it is just what it costs to test timing logic without waiting for time to pass. The suite has grown from 437 tests to 1,044 since, and still finishes in about a second — which is the whole return on keeping the engine pure.
Two thresholds that only real meetings could set
Both defaults were wrong, and both were changed by using the thing rather than reasoning about it:
| Threshold | Was → is | What went wrong |
|---|---|---|
| Minimum duration | 120s → 60s | Three genuine Meet calls measured 90s, 95s and 115s. All three were discarded as "not meetings". |
| Merge gap | 180s → 15s | A 180-second window merged two consecutive Slack huddles with different people into one 71-minute event. |
The second is the more interesting error, because it is asymmetric. Recording two conversations as one is worse than recording one call as two: the first is a false claim about my day, the second is a tidying job. Once framed that way the gap belongs near the bottom of its plausible range, not the middle. The trade-off is explicit and I live with it — muting for longer than 15 seconds ends the session, so a long mute yields two events.
Invalid configuration values fall back to the default with a warning rather than to zero, because a typo'd threshold silently becoming 0 disables exactly the filtering it was there to configure.
A closed allowlist beats a clever heuristic
Plenty of things hold a microphone without being meetings: dictation tools, voice memos, a messenger playing a voice note. The first instinct is a heuristic — duration thresholds, mic-hold patterns, something inferential.
Instead: a closed allowlist of four entries. Slack, Zoom, Teams, and Google Meet in a browser. Anything absent is ignored. Dictation is excluded with no rule and no heuristic, because it was never included.
Two things make that work in practice. The first is that the engine holds no global "microphone is busy" state — sessions are keyed per app and are entirely independent. This is why dictation-during-a-call is correct by construction rather than by special case: the dictation tool is filtered at resolution, and there is no shared state left for it to corrupt.
The second is that matching is on bundle ID prefixes, not exact IDs, and that is not sloppiness. Electron and Chromium apps hold the microphone from a renderer or helper process:
com.tinyspeck.slackmacgap.helper ← Slack's actual mic holder
com.google.Chrome.helper ← Chrome's
us.zoom.caphost ← Zoom's capture host
Prefixes match up to a dot boundary, so com.tinyspeck.slackmacgap catches the helper but not a hypothetical slackmacgapX. A browser additionally needs needsBrowserCheck, which corroborates against the actual tab list — Chrome holding the microphone means nothing until a tab looks like a live call. Firefox is unsupported and permanently so: it exposes no scriptable tab list, so it can never be corroborated.
The failure mode of a closed allowlist is an app quietly changing its bundle ID, which would look identical to "you had no meetings today". So unmatched microphone use is appended to unlisted.jsonl. That file exists for one reason: an allowlist gap should be visible rather than silent.
No name is better than a wrong name
An event reading Zoom call is nearly worthless three weeks later. The useful version names who it was with. There are two routes to that, and one trap.
The route that works beautifully applies to exactly one app: Slack titles its huddle window Huddle: @Someone, so reading the window title (via Accessibility) turns an ad-hoc huddle into Slack huddle — Tushar Yadav. Every other conferencing app exposes no useful window title whatsoever.
So everything else is named from the matching calendar invite — and this is where the trap is. Plain time-overlap matching is not merely imprecise, it is actively harmful, and it is the easy thing to write. Measured against my real calendar: every single recorded session overlapped a day-spanning room booking called "Room for Deployment/Discussions" with ten attendees on it. Several also overlapped a personal "Lunch" block. Naive matching would have confidently labelled every call I take with the same ten people.
The matcher therefore rejects candidates rather than ranking them loosely. An event is not a viable match if it is all-day, has no attendees (a personal block, not a meeting), runs longer than four hours (a room booking, which swallows everything inside it), or is someone else's meeting I merely have visibility of. What survives must also start within 15 minutes of the call — the strongest available signal, where duration is a weak one, since a two-minute appearance in a thirty-minute meeting is a legitimate match. Closest start wins; ties break toward closest duration, which separates a 30-minute invite from a 3-hour one starting at the same moment.
One more rule, small and load-bearing: the attendee list excludes me. That is what makes a one-to-one identifiable by the other person's name — with several people the event takes the meeting's own title, because listing four attendees in a calendar title is unreadable and picking one is arbitrary.
When nothing survives, the event is named Zoom call and stays that way. The governing principle is that no name is better than a wrong name, and a calendar full of confidently wrong attributions is worse than one with some blanks.
Rounded to the quarter hour, and the call that rounds to nothing
A call starts when the microphone opens — 1:58, 2:03 — but a calendar is read by people, and "2 to 3" beats "1:58 to 3:09". Both ends round to the nearest quarter.
Nearest, not outward. Always expanding would inflate every meeting by up to half an hour and turn a day of short calls into a day that looks full.
Rounding is anchored to the containing hour in the local calendar, not to absolute epoch seconds. Every current time zone is offset by a whole number of quarter hours, so epoch arithmetic happens to agree — but it agrees by coincidence, and in a zone offset by 5:53 it would round to times no clock displays. Getting that right costs one line and removes a class of bug that would have been unfindable.
Which leaves the case I like most. A call too short for a quarter collapses to a single point: 12:59 to 13:03 rounds to 13:00 at both ends. Such an event cannot be written — an event needs an end after its start — so the sheet offers Discard instead. Two alternatives were tried and both were worse: pushing the end to the next quarter reported a three-minute call as fifteen minutes, and keeping the raw times made the app's one rounding rule inconsistent for exactly the calls least worth keeping. A range that rounds to nothing is the app saying the call was too short to be worth a quarter of an hour, and Discard is the honest response to that.
Discard has a nice asymmetry in it. It removes the meeting from the app and deletes its event, after confirmation — but the journal keeps the record, marked discarded. The microphone genuinely was held; what I rejected was the meeting being reported, which is a different claim from it not having happened.
The journal always keeps what was actually observed. Only the calendar event gets the tidied times, with the original shown struck through above the editable fields — and only when rounding genuinely moved something, rather than printing the same time twice for a call that already started on a quarter.
Writing to a calendar exactly once
Everything about calendar writing is shaped by the fact that a duplicate event is a real, visible, annoying bug, and the app runs unattended.
The append-only journal is the idempotency source of truth, and it is written before the calendar — an ordering with its own test suite. A session interrupted mid-write is picked up on the next launch and written once, not twice. Pressing "add" twice cannot create two events. Turning automatic adding back on backfills every meeting journalled while it was off, rather than silently applying only to future calls.
The constraint I set and did not relax: it never touches an event it did not create. It adds events, reads them, and can retitle, retime or delete the ones it wrote — identified by the event identifier stored in its own journal at write time, which is also why events written under the app's old name are still recognised as its own. Someone else's event is never modified or deleted, ever.
The reverse case is handled too, and is the one people actually hit. Delete a written event from Calendar and the app notices on the next refresh, drops the tick, and offers to add it again — but will not re-add it on its own, because deleting it was a decision, not an accident to be helpfully undone.
The destination is chosen by the user and nothing is written until it is, because it is a privacy decision that is genuinely theirs to make: a local "On My Mac" calendar never leaves the machine, iCloud is personal but syncs to Apple, and a work account is the most useful place to reconstruct a working week and is visible to colleagues — with event titles that include who the call was with. The app never creates a calendar, and never writes anywhere it was not pointed.
Similarly, the calendars shown on the timeline start unticked. The alternative default, showing everything, turns granting Calendar access into a dashboard full of every event from every account — which reads as the app having overstepped, and would be right.
A second destination, and the difference between "deleted" and "couldn't ask"
A calendar answers when did this happen. A timesheet answers what did the week go on, and those are different questions asked by different people. So a detected meeting can also be logged to Toggl Track, independently of the calendar — time without an event, an event without time, or both.
Two things about the shape of it. TimeTracker is its own target rather than an extension of CalendarWriter, because the two destinations share nothing but the session they are handed, and folding a network client into the EventKit module would make either one untestable alone. And entries use the same quarter-hour rounding as the calendar events — two systems disagreeing about when the same meeting happened is worse than either being slightly wrong, and a call that rounds away to nothing is refused here too, by the same check.
The token lives in the login Keychain rather than in the app's preferences, which is not ceremony: it can read and write a work account's time entries, and a preferences file is readable by anything running as you. Toggl's own auth is the trap that earns a unit test — the token is the username and the literal string api_token is the password, and swapping them fails identically forever. Entries also carry created_with: "Tick-Tock", so an entry this app made can be told from one you typed.
But the interesting bug is the idempotency one, because the first version looked correct. It recorded that a meeting had been logged and refused to log it twice. That is a claim about the past, and it was quietly wrong about the present: delete the entry in Toggl and the app still insisted it was there, so the meeting could never be re-logged — while a surviving entry got duplicated on every press.
So it asks Toggl before writing, and the fix hinges on refusing to collapse three answers into two:
| What Toggl says | What happens |
|---|---|
| The entry is still there | Nothing is added — Already in Toggl |
| It was deleted | A replacement is created, and says so |
| Toggl cannot be reached | Nothing is written, and it says so |
That third row is the whole lesson. "Deleted" and "could not ask" are different answers, and treating a network failure as deletion duplicates an entry that was there all along. The protocol method therefore throws rather than returning false — a boolean has nowhere to put "I don't know", which is exactly the value that matters.
Automatic logging is off by default, and the flag is read at write time rather than captured at startup, so turning it on in Settings applies to the next meeting instead of the next launch.
Today's note, and a corner macOS will not let me have
The other thing that lives beside a reconstructed day is what you wrote during it. macOS already ships a hot corner that opens a note — Quick Note — and it is unusable as a daily journal for two reasons, neither configurable: it reopens the last note rather than one per day, and it opens Apple Notes, which is not where the work lives.
The obvious fix is to add this app to the Hot Corners list. That list is fixed by the OS and no third-party app can extend it. So the corner has to be built here, which turns a small convenience into four decisions worth recording.
The corner is polled, not monitored
A 100ms timer reading NSEvent.mouseLocation, rather than a global mouse-moved monitor. Everyone assumes that choice is about permissions, and it is not — mouse events need no grant. Three other things decide it:
- A dwell is the wrong shape for an event stream. Dwelling means the cursor has stopped, and a stopped cursor emits no mouse-moved events. The interesting state produces zero callbacks, so the timing has to happen out of band anyway — at which point the monitor has bought nothing and added a second mechanism.
- A global monitor does not see events destined for this app, and the dashboard opens at
visibleFrame, covering the bottom-right corner. It would need a paired local monitor and two coordinate conventions reconciled. mouseLocationis a global query, so it answers identically over another app's window, a full-screen app, the Dock and the menu bar.
The cost is one cheap read every 100ms, with timer.tolerance set so macOS coalesces the wakeups. And the decision that follows from it matters more than the polling: the logic is a pure value-in, value-out state machine holding no AppKit and no clock. Its import list — CoreGraphics and Foundation — is the visible proof, the same way the session engine's single dependency edge is.
Which means every rule anyone would get wrong is reachable without a window server or a cursor:
✔ Test "a fresh detector will not fire, even with the cursor already parked in the corner"
✔ Test "a held mouse button will not fire, however long the cursor sits there"
✔ Test "a backward clock jump restarts the dwell instead of firing early"
✔ Test "re-entering restarts the dwell from zero rather than resuming it"
✔ Test "leaving the corner is what arms it"
✔ Test "an unrecognised stored corner falls back rather than disabling the feature"
The first is the login-item case: the app starts with the pointer already in the corner, which must not count as a request. The second is someone dragging a file to the Trash. The hysteresis — a release zone deliberately larger than the trigger zone — exists because one point of jitter at the boundary otherwise lets the cursor "leave" and immediately re-fire without the hand moving.
The corner offers; the click commits
Originally the corner opened the note itself once the dwell elapsed. It now shows a hint and waits for a click — which is what macOS's own Quick Note corner does, and I came to it the same way Apple presumably did.
The dwell, the hysteresis and the held-button guard all exist to stop an accidental brush from doing something. Requiring a click removes that entire class of problem instead of defending against it: the worst an accidental brush can now do is show a panel that fades when you move away. The dwell now means "how long before the hint appears" rather than "how long before it acts".
That needed a new state, revealed, distinct from suppressed even though both refuse to re-fire — because the difference is whether a hint is on screen, and reusing suppressed made the hint vanish the instant it appeared.
The global shortcut uses Carbon, in 2026
RegisterEventHotKey rather than an NSEvent key monitor, for ⌃⌥⌘N. A key monitor requires Accessibility and fails silently without it — the monitor object is returned and the handler simply never runs. More decisively, it is observe-only by contract and cannot consume the keystroke, so the same keys would also type into whatever app is frontmost. There is no combination that is safe under that constraint.
Carbon registers rather than observes, needs no grant, works for an accessory app, and reports a conflict as an OSStatus at registration time instead of as silence at press time. An old API that answers the question correctly beats a modern one that cannot.
One writable copy, and three ways an API can eat your writing
Notion holds the note. The original decision was that it holds the only copy and is also the only editor, on the grounds that a second writable copy brings block↔markdown round-tripping, change detection and conflict resolution — a class of problem best not created.
Then Notion shipped first-class markdown for page content: GET and PATCH /v1/pages/:id/markdown, with Notion performing the conversion in both directions. The lossy converter I had refused to write no longer needed to exist, so the editor moved into the app — and the honest accounting is that two of the three predicted costs were real and are simply paid:
| What was avoided | What actually replaced it |
|---|---|
| Lossy block↔markdown conversion | Notion's own markdown endpoints — no converter here at all |
| Change detection | A pure three-way comparison over baseline, local and remote |
| Conflict resolution | Read-before-write, and asking the user in the one case that needs it |
The rule, stated once: with edits on both sides, refuse and ask. With edits on one side, take that side. With none, or with both converged on the same text, do nothing. It is a pure function over three strings and it has its own type, because the write endpoint replaces the whole page — so an error there destroys somebody's writing, which is worth more care than the HTTP call around it.
1. HTTP 200 is not content success. replace_content clears the page and then parses the markdown, so markdown Notion cannot parse leaves an empty page and still answers 200. This destroyed a real 1,325-character note. Every write now checks the markdown echoed back in the response: content in and nothing out throws. The check can only run after the page has been cleared — that is inherent to the endpoint — so it reports rather than prevents, and says to go and look at Notion's page history, which is where the note still is.
2. The baseline after a save is Notion's text, never the text that was sent. Notion re-renders markdown — #### escaped, * swapped for _, blank lines collapsed — and treating that normalisation as a local edit made every second save of a session a false conflict. There is a test named exactly that: the baseline handed back is Notion's text, not the text that was sent.
3. A truncated read makes the note read-only rather than saveable. When Notion returns a page in pieces, writing that partial read back with replace_content would delete everything it omitted. That is the one genuinely unrecoverable thing this feature could do, so it refuses and points at Notion instead.
There is now a local mirror at notes/YYYY-MM-DD.md, which looks like a reversal of "one copy" and is not. The mirror is never written by a person — it holds whatever was last read from or sent to Notion, so there is still exactly one writable copy and nothing to merge. It is written from what Notion holds after a save rather than from what was sent, which keeps it a faithful record of the store including Notion's own re-rendering. What changed the calculus was that "the only copy lives in someone else's service" stopped being hypothetical the moment failure mode 1 emptied a real note.
Offline editing was deliberately unbuilt for a while, on the grounds that it needs the mirror to become writable — the two-copies problem again. It now exists, and it dodges that by keeping pending edits in a separate file: .YYYY-MM-DD.md.pending, beside the mirror and never in it. The mirror stays the last thing Notion is known to have held, so it is still the baseline a save compares against — meaning a note edited in Notion while you were offline still produces the same conflict question, however long the gap was. Pending edits being a file rather than memory is what makes a closed lid or a flat battery survivable.
Two smaller decisions I like. The API version is pinned to the oldest release that models a database as a parent of data sources, because the simpler older version fails on page creation the moment somebody adds a second data source in Notion's own UI — a silent failure triggered by an action taken in a workspace this app does not control. And hashtags in a note are derived from the text rather than stored beside it: deleting #deploy from a note removes the tag, because the text said so. That needs its own three-way merge too — replacing the page's tags with whatever the note says would delete a tag added in Notion, and taking the union would mean a tag could never be removed. Notion's casing wins where it has an opinion, since sending deploy when the page holds Deploy creates a second option meaning the same thing.
One thing got deleted and that was the best change of the lot. Opening the note in a new Notion window had required driving Notion's File → New Window menu item over the Accessibility API — somebody else's UI, verified against one Notion version, and the most fragile code in the project. Moving the editor into the app removed the only reason that code existed, and the three-way "where should this open" setting with it. A single button remains for opening the real page in Notion, as an escape hatch rather than a mode.
The line the activity timeline does not cross
Alongside meetings, the dashboard shows the day as 96 quarter-hour rows: which app I was using in each block, labelled with the one used most, with a red line at the current time.
That timeline is deliberately never written to a calendar, and the reason is not technical. Dozens of events a day would bury the real meetings — but more than that, a minute-by-minute record of what you used is a materially different privacy proposition from "you were in a call". One is a meeting log; the other is surveillance with your own name on it. It renders in the app's own window, has no export path, and a single block can be added by hand if I want it.
Three details in that grid took more thought than they look:
- Idle is idle. A locked screen or running screen saver counts as nothing frontmost, not as the app that happened to be open. Without that, a Mac left alone overnight reports eight hours of solid activity in whatever was on screen.
- Durations are derived, not assumed. A slot's time is divided by its actual sample density — 15 samples in a 15-minute slot makes each worth a minute; 3 samples makes each worth five. Assuming full density would report a slot the app was only alive for part of as if it owned the whole thing.
- A meeting covers no more grid than it lasted. It occupies the rows holding its time, so a 3-minute call is not drawn as half an hour, and a 27-minute one that runs 41 seconds past the half hour is not drawn as 45 minutes.
There is also an honest hole: no history from before you install it. macOS exposes no record of which app was frontmost in the past, so the timeline starts on first run. Past scheduled meetings come from the calendar and so work retroactively, which makes the asymmetry look like a bug and it isn't one.
What a rename cannot change
The app was called Mac Activity Hub and is now Tick-Tock. Three things kept the old name, because renaming them destroys data or permissions rather than relabelling anything:
- The bundle identifier
com.shivam.macactivityhub. macOS keys Calendar, Accessibility and Automation grants to it — andUserDefaultstoo. Changing it means re-granting every permission and losing every setting. ~/Library/Application Support/MacActivityHub/, which holds every recorded session and every day of activity. Renaming it orphans all of it.- Events already on calendars, still recognised as the app's own — otherwise a past call could be mistaken for a scheduled meeting and used to name a new one.
Only CFBundleExecutable was renamed, which is what Activity Monitor displays. A rename is a UI change; identity is not, and the two get confused because they usually look the same.
Permissions have one more macOS-shaped consequence worth recording. Grants are tied to an app's code signature, and ad-hoc signing produces a new signature on every build — so every recompile would look like a new app and silently drop the Calendar and Accessibility grants. Hence a self-signed certificate created in the login keychain, trusted for code signing only, no sudo and no system-wide trust. It exists purely so that rebuilding does not cost you your permissions, and not for distribution at all.
Installing it, and why the first launch is a refusal
That self-signed certificate has a consequence for anyone else: macOS refuses the app the first time, and correctly. It has never been through Apple's notarisation service, because notarisation requires the paid Developer Program. Here is exactly what your Mac sees, and none of it is a defect:
$ spctl --assess --type execute -vv Tick-Tock.app
Tick-Tock.app: rejected
origin=Mac Activity Hub Dev
$ codesign -dvv Tick-Tock.app
Authority=Mac Activity Hub Dev
TeamIdentifier=not set
$ xcrun stapler validate Tick-Tock.app
Tick-Tock.app does not have a ticket stapled to it.
$ codesign --verify --deep --strict -v Tick-Tock.app
Tick-Tock.app: valid on disk
Tick-Tock.app: satisfies its Designated Requirement
Rejected, a self-signed authority, no team identifier, no notarisation ticket — the honest signature of software nobody bought a certificate for. Worth weighing before running it, the same as anything else distributed this way. The last two lines are the ones that matter for diagnosis: the signature is intact. That is why you get the ordinary "cannot verify the developer" block, which has an Open Anyway button, rather than "Tick-Tock is damaged and can't be opened", which is the message for a broken signature and has no such button. If you ever see "damaged", the download truncated — fetch it again.
So: double-click it and let it be refused, clicking Done rather than Move to Trash. Then System Settings → Privacy & Security, scroll to the Security section at the bottom, and a line has now appeared offering Open Anyway. Authenticate, confirm once more, and that is it — once per Mac, and again per new version you download. The entry does not linger indefinitely, so if it is missing, launch the app again and look immediately.
On macOS 15 and later that is the only route. Control-clicking an app and choosing Open was removed, so any older instructions describing that simply do not work any more. On a managed work Mac, MDM policy can remove the Open Anyway option altogether — build from source there instead, which sidesteps the whole dance because an app you compiled locally was never quarantined.
Two hard requirements before any of that, one of which fails in the worst possible way:
| Requirement | Why | If you don't have it |
|---|---|---|
| Apple Silicon | The build ships a single arm64 slice |
Nothing happens at all. Rosetta cannot help — it translates Intel to Apple Silicon, not the reverse |
| macOS 14.4+ | CoreAudio process objects, the entire detection mechanism | Will not run. There is no fallback |
| A calendar account | Meetings are written through EventKit | Runs fine, but has nowhere to write |
The Intel case is the one that bothers me: an arm64-only binary on an Intel Mac fails silently rather than explaining itself. That is a packaging decision I should revisit — a universal binary costs build time and nothing else.
Declining a permission is never a dead end, which took more work than granting one. The app asks once — re-asking at every login, which it does start at, is nagging — and afterwards a Permissions tab shows what is missing with a button that opens the exact Privacy & Security pane. That matters most for Calendar, which macOS prompts for exactly once and never again, making that button the only way back. Accessibility is stranger still: macOS permits no dialog that grants it, so the "prompt" is only a redirect to System Settings, and the app watches for the moment you flip it.
Tech, and where it stands
CoreAudio → AudioProcessKit → MicMonitor → SessionEngine → Journal
(C interop) (listeners) (PURE logic) → CalendarWriter
→ TimeTracker (Toggl)
→ Dashboard
mouseLocation → HotCornerWatcher → HotCornerDetector → DailyNote → Notion
(100ms poll) (PURE logic) (markdown API)
Swift 6 on SwiftPM, no Xcode project. The split between the two UI frameworks fell out along an honest seam: AppKit owns the shell — status item, window lifecycle, the main menu, and a Dock icon that appears only while a window is open — because all of that is exactly the window-management work SwiftUI is worst at on macOS. SwiftUI owns what is inside the windows, the dashboard and settings, which is the declarative-list-of-rows work it is best at. It is an accessory app (LSUIElement), so there is no Dock presence until it earns one.
Fourteen targets, split so the pure ones can be kept pure — and the two newest carry the same discipline for different reasons. TimeTracker is separate from CalendarWriter because the destinations share nothing but the session handed to them. DailyNote depends on Support and nothing else, deliberately not on SessionEngine: it is a network client that has no idea what a meeting is, and an edge between them would invite two unrelated features to grow into each other. It owns no AppKit either, so opening a URL stays the coordinator's job and the target stays testable headless.
Three append-only JSONL files — sessions, unlisted microphone use, and one activity file per day — where a single bad line is skipped rather than poisoning the file. Alongside them, one markdown file per day mirroring each Notion note, plus a hidden stamp recording when Notion last edited that page so an unchanged note is not downloaded again. All of it safe to delete, because the app recreates what it needs and refetches a missing mirror.
Nothing is written to a calendar until you pick a destination, and then only automatically if you also tick Add them automatically, which is off by default. With it off the app still detects and journals everything; you add meetings one at a time. Turning it on later backfills what was journalled while it was off.
Twenty-four releases so far, currently v1.13.1, in daily use on my own machine. Everything above that reads as a considered design decision was, in practice, a bug I hit first: the merged huddles, the discarded 90-second calls, the ten-attendee room booking attached to every call, the three-minute meeting that could not be saved, a locked Mac reporting a productive night, a Toggl entry duplicated because "deleted" and "couldn't ask" had been collapsed into one answer, and a 1,325-character note deleted by an API call that returned 200.
The shape of the growth is worth noting, because it was not planned. The app started as one question — which app holds the microphone — and the two features added since are neither about microphones nor about meetings. What they share is the same premise the app began with: the useful record is the one the machine can produce without being asked, and the human's job is to confirm it rather than to type it.
Licensed Apache-2.0 rather than MIT, deliberately. MIT would permit taking it, renaming it and republishing it as your own, which is the one thing the licence is here to prevent. Apache-2.0 requires attribution, requires stating what changed, and grants no rights to the name — section 6 covers trademarks, so the code may be reused while "Tick-Tock" may not be reused to describe a derivative. None of which actually prevents copying: a signed binary on someone else's Mac is entirely under their control and can be renamed and re-signed in three commands. What the licence does is make stripping authorship a deliberate act rather than an oversight, which is the most any licence achieves.
The repository is still private, so there is no source link or download above — the write-up is the public artefact for now. What is public is the reasoning: three ADRs carry the decisions above, including the one that reversed itself when Notion's API changed under it, which is the only honest way to record a decision that turned out to be contingent rather than principled.