Hooks

Write a hook

A hook is one executable file: ~/.takku/hooks/after-processing (no extension). Start it with a #! line for the language you use—#!/bin/sh for a shell script, #!/usr/bin/env python3 for Python, #!/usr/bin/env node for JavaScript.

When a meeting is ready, and again after every regenerated summary or reprocessed recording, Takku runs it in your notes folder with two arguments: the path of the meeting note ($1) and the path of the transcript ($2). The simplest hook commits the folder to git:

#!/bin/sh
# $1: the meeting note, $2: the transcript
git add -A && git commit -qm "Meeting: $(basename "$1" .md)"

To create it, make the file, make it executable, and open it in your text editor:

mkdir -p ~/.takku/hooks
touch ~/.takku/hooks/after-processing
chmod +x ~/.takku/hooks/after-processing
open -t ~/.takku/hooks/after-processing

• Without the file nothing happens: there is no setting to turn on. Without chmod +x, Takku tells you it can’t run it.
• Regenerating or reprocessing a meeting runs the hook again, so update what the first run created rather than creating it twice. The note’s takku_id never changes: use it for that.
• Takku writes every run to ~/.takku/hooks/after-processing.log, with the command to run it again by hand. If the script fails, a notification says so, and Takku leaves the meeting as it is.
• To run it by hand on any meeting, call it with the note’s path: it’s a plain script.
• The hook finds Homebrew’s tools, and Takku stops a script still running after 5 minutes.
• The script runs with Takku’s permissions, microphone and screen recording included, and sends your meetings wherever you tell it to. Put there only code you trust.

Every meeting in Notion

A ready-made hook, notion.py, copies each meeting note (the summary and your notes, without the screenshots) to a Notion page under a page you choose, and updates the same page when a summary is regenerated. It needs Python 3, from Homebrew or the Xcode Command Line Tools.

1. In Notion’s developer portal, open Internal connections and create a new connection for your workspace, with read, update and insert content turned on. Copy its API token. a connection sees only the pages you share with it
2. Save the token in the Keychain, pasting it when asked:

   security add-generic-password -a "$USER" -s takku-notion -w

3. Open the page the meetings will go under. In its ••• menu, choose Connections, Add connection, and pick yours. Copy the page’s link: its ID is the 32 characters at the end.
4. Install the script as your hook, then write the page ID in PARENT_PAGE_ID at its top: for more than one hook, save it as notion.py instead: see below

   mkdir -p ~/.takku/hooks
   curl -fsSL https://raw.githubusercontent.com/mameli/Takku/main/examples/hooks/notion.py \
     -o ~/.takku/hooks/after-processing
   chmod +x ~/.takku/hooks/after-processing
   open -t ~/.takku/hooks/after-processing

5. Try it on a meeting you already have, then look for the page in Notion:

   ~/.takku/hooks/after-processing "/path/to/notes/Meetings/a meeting.md"

From then on every meeting goes to Notion as soon as it is ready.

Let your agent write it

If you use a coding agent (Claude Code, Codex, Copilot CLI, Cursor…), it can set up the hook for you: hooks.md is this page written for agents, with what Takku passes to the hook, the format of the files and the rules to follow. Paste this to your agent, and say what you want the hook to do:

Read https://takku.app/hooks.md and set up a Takku hook that …

For example, a summary of every meeting from a subscription you already have, such as Copilot, Claude or Codex: record with Transcript only and let the hook ask your assistant. You lose what Takku does around its own summary: the template, the vocabulary, the speaker names and the title of the note. The agent asks you which meetings it may send; a meeting with a customer is the customer’s data.

More than one hook

Takku runs only after-processing. To do more than one thing, keep each hook in its own file in the same folder, and make after-processing run them in turn. For example, Notion for every meeting, git for every meeting, and Confluence only for the notes you tagged confluence:

#!/bin/sh
# ~/.takku/hooks/after-processing: runs the other hooks in turn
hooks="$HOME/.takku/hooks"
failed=0

"$hooks/notion.py" "$1" "$2" || failed=1
"$hooks/git-commit" "$1" "$2" || failed=1

# Only the notes tagged confluence
if grep -q '^tags:.*confluence' "$1"; then
  "$hooks/confluence" "$1" "$2" || failed=1
fi

exit $failed

• Each hook runs even if the one before failed, and the notification still tells you something went wrong.
• Every file it calls needs its own #! line and chmod +x, like after-processing. Their names are up to you: Takku never runs them by itself.
• The 5 minutes count for after-processing as a whole, the hooks it calls included.