The agreement, clause by clause

Accountability partner agreement: seven clauses enforced by code, not a PDF

Every template you will find for this topic is a Google Doc with blanks. On vipassana.cool nothing gets countersigned. The agreement is enacted by one click on a confirmation email, and its seven clauses are enforced by seven specific files in this repo, each one a single line or a single SQL statement. No signatures. No notarization. Just runtime.

M
Matthew Diakonov
9 min read
4.9from direct meditator feedback
Every clause tied to a file path and line number in a public repo
Free, in the dana tradition — no minimum commitment, no clawback
No operational practice instruction; technique goes through dhamma.org

The agreement in four numbers

A PDF template has blanks. A code-enforced agreement has constants. Here are the four that matter most.

0clauses, each tied to one file and one line
0 daysto confirm, or the match is voided automatically
0SQL UPDATE to end every active partnership at once
0signatures, notaries, or countersigns required

What other guides on this topic actually give you

I read the pages that currently show up at the top for this phrase. They are, almost without exception, the same artifact: a fillable agreement template. A title block, two name fields, a shared goal, a meeting cadence, a consequence for missing a check-in, a dispute clause, and a line to sign. The best of them includes 10 well-worded clauses and a printable layout. The worst is a page of generic bullet points pretending to be a contract.

Templates like that work for two people trying to invent a partnership from scratch. They do not work for a product where the partnership shape is already decided and the runtime already knows how to enforce it. What a template solves by asking partners to fill in blanks, this product solves by already having every blank filled in: daily cadence, one permanent Meet URL, a 3-day confirmation window, a one-click exit. The agreement here is not a document you agree to. It is the behavior the product will produce on your behalf, now that you have said yes.

One click, seven clauses fire

The confirmation-email click is a branching event. The left side of this diagram is the offer. The hub is the yes click. The right side is the set of clauses that come into force as a result, each one attached to the file that enforces it.

confirm-match yes click, fanning out to the seven clauses

Confirmation email
Yes click by partner A
Yes click by partner B
/api/confirm-match
Cadence: RRULE:FREQ=DAILY
Permanence of URL
3-day confirm window
Click heartbeat
Unilateral exit
No repeat pairing
Pre-existing conditions

The seven clauses, one by one

Each cell below is one clause of the agreement. The card text is the clause in plain English. The source reference is where the clause lives in the runtime, and what it does.

Clause 1. Cadence

The partnership repeats daily. Set on src/lib/google-meet.ts line 75 as recurrence: ['RRULE:FREQ=DAILY']. Weekly or monthly is not an option the product offers.

Clause 2. Permanence

The Meet URL does not rotate. src/lib/emails.ts line 288 types the exact sentence partners read: 'This link is permanent, use it every day, at any time.'

Clause 3. 3-day confirmation window

Both sides must click yes within 72 hours, or the match is voided. src/lib/emails.ts line 376 states it; expire-matches/route.ts:11 passes 3 to expireStaleMatches to enforce it on a cron.

Clause 4. Click heartbeat

Every open of /meet/<token> writes one row to meet_clicks with token, match_id, person_id, URL, IP, and user agent. Two rows a day per pair is the ambient proof the partnership is still alive.

Clause 5. Unilateral exit

Either partner can end the partnership at any time. The footer of any email contains an unsubscribe URL; one click hits /api/unsubscribe, which does UPDATE matches SET status='ended' on every active match for that person_id in one pass.

Clause 6. No repeat pairing

If a pairing ends, the matcher will not re-pair the same two people. getPriorMatchedIds in auto-match/route.ts filters the candidate pool to exclude anyone you were matched with before. A new partner is preferred to a rematch.

Clause 7. Pre-existing conditions

You represent that you have self-assessed your fitness for intensive meditation. The disclaimer page (src/app/disclaimer/page.tsx:60 to 73) spells out the mental-health caveat and points at professional advice for anyone with relevant history.

Clause 1, in code: the cadence

The line that turns a one-off Meet into a daily partnership is recurrence: ["RRULE:FREQ=DAILY"]. Remove that line and the product is a one-off introductions service. Change it to weekly and the product becomes a call-club. The keyword reason the product says the word daily so often is that this one line says it first.

src/lib/google-meet.ts

Clause 3, in code: the 3-day confirmation window

The only time-boxed provision in the whole agreement. Both partners have 72 hours to accept. If they do not, the match is voided and both names go back on the waitlist. The cron below is the enforcement.

src/app/api/expire-matches/route.ts

Clause 5, in code: the unilateral exit

One click on the unsubscribe footer link. One database pass. Every match in any of the five active-ish statuses ends in the same transaction. The partner is notified and dropped back on the waitlist as ready. There is nothing to renegotiate and nobody to confront.

src/app/api/unsubscribe/route.ts

Acceptance, diagrammed

What the click actually does, message by message, between the browser, the matcher, Postgres, Google Calendar, and Resend. No step is invisible. Every step is a single function call.

yes click, fully expanded

Partnerconfirm-matchPostgresGoogle CalendarResendGET ?token=X&response=yesUPDATE person_a_confirmed=trueboth_confirmed=truePOST events, recurrence=DAILYmeet_url, event_idINSERT 2 rows meet_linkssend intro email to bothredirect /match-confirmed

Lifecycle of the agreement, end to end

Offer, acceptance, operation, void, exit, successor. Every agreement has these phases. In a signed contract they are names on a page. Here they are states the matches.status column walks through.

1

Offer (the confirmation email)

The matcher creates a 'confirming' row in the matches table and sends a confirmation email to each side with a token and two buttons. This is the offer: the hyperlinks are the terms, and the click is the acceptance. At this moment no Meet URL yet exists.

2

Acceptance (both yes clicks)

Each click to /api/confirm-match flips one of person_a_confirmed / person_b_confirmed to true (src/app/api/confirm-match/route.ts:57). When the second click lands, confirm-match runs createMeetEvent, inserts two rows into meet_links, and emails the intro. The agreement becomes operative at the instant of the second click.

3

Operation (daily heartbeat)

From acceptance onward, the only ambient signal is meet_clicks. Two rows a day, roughly at the same time, at the same token pair, is the heartbeat. The operator dashboard reads this to tell healthy pairs from quiet ones without asking either partner anything.

4

Void (3-day timeout)

If the acceptance never completes (one party clicks no, or neither clicks), expire-matches/route.ts runs on its cron, calls expireStaleMatches(3), deletes the confirming rows older than 72 hours, and emails the operator a summary. Both people are returned to the waitlist. No Meet URL was ever created.

5

Exit (unsubscribe click)

Either partner clicks the unsubscribe link in any email. src/app/api/unsubscribe/route.ts reads every matches row where the person is on either side, runs UPDATE matches SET status='ended' on each, sets the partner's status back to 'ready', writes an activity log row, and emails the partner a short 'no longer available' note. One click, all active partnerships for that person, ended transactionally.

6

Successor (re-match, skipping history)

Whoever is still on the waitlist after an exit gets re-matched on the next run of the matcher cron. getPriorMatchedIds excludes the former partner from the candidate pool. The new match is with a fresh person, not a do-over.

The entire exit provision, in one SQL statement

Everyone who has ever tried to dissolve a partnership agreement by email knows the awkwardness of it. Two drafts, three apologies, one or two days of limbo. In this product the entire exit clause is 0 click, executed against 0 possible match states, resolved in 0 SQL transaction. No conversation is required. The other person is told, courteously, that their partner is no longer available and that a replacement will be along. If the partnership ended for a reason the operator should know, a short email to matt@vipassana.cool is welcome; it is not required.

Template agreement vs. code-enforced agreement

FeaturePDF / Google Doc templatevipassana.cool
Form factorA Google Doc template or printable PDF with blanks.A set of code paths, email strings, and SQL statements across 7 files.
Who fills in the blanksThe two partners, by hand, at the start.The product, automatically, at signup and at matching time.
How cadence is setWritten into a sentence: 'we agree to meet every Tuesday at 7am'.recurrence: ['RRULE:FREQ=DAILY'] in google-meet.ts line 75. The string is the schedule.
How a missed session is detectedManually, by the other partner noticing.Silence in the meet_clicks table, visible to the operator without anyone having to report anything.
How exit worksA conversation. Sometimes an awkward one.One click on the unsubscribe link. One SQL UPDATE. All active matches end in the same transaction.
Enforcement mechanismMutual goodwill.A daily-firing calendar event, a cron job, and a redirect-with-logging route. None require either human to remember anything.
CostVaries. Coaching variants can run $100 to $500 per month.Free. The matching is run in the dana tradition of the lineage it serves.
ScopeAnything, because the document is blank until you write in it.Exactly one thing: a daily Vipassana practice partnership over Google Meet.
1

The link is permanent. Use it every day, at any time.

literal string on src/lib/emails.ts line 288, rendered into every intro email

Tokens of the agreement, in the language the runtime speaks

Templates on this topic typically use words like commitment, accountability, consequence. The runtime on this site uses these tokens instead. Every one of them is something the code can check.

recurrence: ['RRULE:FREQ=DAILY']'This link is permanent''This match expires in 3 days'expireStaleMatches(3)INSERT INTO meet_clicksUPDATE matches SET status = 'ended'getPriorMatchedIds(personA.id)person_a_confirmed && person_b_confirmedreplyTo: [personA.email, personB.email]status IN ('confirming','pending','replied','scheduling','active')

Why the agreement is deliberately this thin

A thicker agreement, with declared goals and agreed consequences and weekly written check-ins, would be a richer contract. It would also be the wrong contract. The tradition this product orbits is Goenka-style Vipassana, and the tradition is taught on a donation basis, by authorized assistant teachers, at 10-day residential courses run through dhamma.org. The teaching of technique is not something a web product can legitimately do. What a web product can legitimately do is help two meditators reliably open the same Meet room at the same time every day. That, and exactly that, is the scope of this agreement. If the scope were wider, the product would be impersonating a teacher it is not authorized to impersonate.

For anything about how to sit, how to handle a difficult session, or how to work with whatever arises on the cushion, the correct redirect is dhamma.org and a conversation with an authorized assistant teacher in person, at a course. The seven clauses here do not pretend to cover any of that. They cover the infrastructure. The practice itself is a separate, older, and much larger agreement with a lineage.

Want to walk through what the seven clauses look like for your schedule?

Book a short call. We'll go through the signup, the matcher, and what the agreement fires when you click yes, end to end.

Frequently asked questions

Do I sign an accountability partner agreement when I join Practice Buddy?

Not in the paper sense. Nothing gets countersigned and no PDF is exchanged. The agreement is enacted the moment you click the 'Yes, introduce me' button in the confirmation email, which hits /api/confirm-match?token=<your token>&response=yes. That click is logged, flips person_a_confirmed or person_b_confirmed to true, and, once both sides have clicked, triggers the run that creates the Meet URL, writes the meet_links rows, sets the calendar recurrence, and sends the intro email. From that moment on, the terms listed on this page apply to you. The closest thing to a 'document you agreed to' is the confirmation email itself: the URLs in it are the offer, and the click is the acceptance.

What are the seven clauses, in one sentence each?

One, the cadence clause: the partnership repeats daily (recurrence: ['RRULE:FREQ=DAILY'] on src/lib/google-meet.ts line 75). Two, the permanence clause: the Meet URL does not rotate and is reused forever (src/lib/emails.ts line 288, the literal sentence 'This link is permanent, use it every day, at any time'). Three, the 3-day window clause: if both parties do not confirm within 3 days the match is voided and both go back on the waitlist (src/lib/emails.ts line 376, enforced by src/app/api/expire-matches/route.ts line 11). Four, the heartbeat clause: every click to /meet/<token> is logged to meet_clicks with IP and user-agent (src/app/meet/[token]/route.ts lines 26 to 29). Five, the unilateral-exit clause: either party can unsubscribe and all active matches for them end in one SQL UPDATE (src/app/api/unsubscribe/route.ts line 59). Six, the no-repeat clause: once paired with someone, the matcher will not pair you with them again (src/app/api/auto-match/route.ts, getPriorMatchedIds, lines 241 to 245). Seven, the pre-existing-condition clause: you represent that you have assessed your own fitness to sit intensive sessions, stated in src/app/disclaimer/page.tsx lines 60 to 73.

What makes this different from a typical accountability partner agreement template?

Typical templates are Google Docs with blanks: 'We, <Partner A> and <Partner B>, commit to meeting every <frequency> for <duration> to work toward <goal>. If one party misses <n> sessions, the consequence is <X>.' The document is the contract. Here, no document is the contract. The product already knows the cadence (daily), the duration (your session length chosen at signup), the channel (one specific meet.google.com URL), the partner (resolved by the matcher), and the consequence of inactivity (silence in meet_clicks, which is visible on the operator dashboard). Filling in a template would be redundant, because the template is already filled in by the runtime. What the templates give you, essentially, is a hand-rolled version of what this product automates. The downside of the hand-rolled version is that nothing enforces it. The downside of the code-enforced version is that it is narrow: only one kind of partnership (daily Vipassana sits) is supported.

Is there a written 'terms' I am accepting when I use the matcher?

Yes, and it is the slimmest plausible version of one. /terms covers the service-level agreement (free matching, no guarantees, participation is voluntary, we are not responsible for what happens between matched users). /privacy covers data handling (email stored, anonymous PostHog analytics, unsubscribe anytime). /disclaimer covers the mental-health caveat (if you have a history of certain conditions, talk to a professional before an intensive course). These three pages are the legal layer, and the seven clauses on this page are the operational layer sitting on top of them. The two layers do not conflict. The operational layer is what determines day-to-day behavior of the product; the legal layer is the background contract with the service itself.

Can the agreement be modified once it is active?

Not by the two partners, not in the way a legal contract can be amended. The product does not expose a 'change cadence' button, a 'move the URL' button, or a 'renegotiate the window' button. If something has to change, either party uses the unsubscribe link to end the partnership and rejoins the waitlist with new preferences. The operator, Matt, can edit the calendar event manually (that is how the calendar_event_id column on the match row exists). In practice this only happens in recovery scenarios (a broken URL, a guest-permission issue). The unchangeability of the agreement, mid-flight, is intentional: the whole point is to move the commitment out of reach of a tired future self who wants to renegotiate at 5:30 in the morning.

What happens if one partner just stops showing up?

Nothing immediate. There is no automatic nag, no missed-session penalty, no public leaderboard. The only signal is meet_clicks: if only one token shows clicks for N days, the operator dashboard flags the pair. The default resolution is to reach out over email (the intro email thread already includes both addresses in replyTo). If the ghosting continues, the remaining partner can unsubscribe and rejoin, and the matcher will pair them with someone new (skipping the ghost, because getPriorMatchedIds remembers the prior match). The system's theory is that an accountability partner whose partner has quit is not being held accountable, and the best thing to do is get them a live partner as fast as possible, not to manufacture guilt.

Is there a minimum commitment period?

No. There is no 30-day minimum, no 'trial' that auto-converts to a paid plan, no clawback if you leave early. The only time-boxed clause is the 3-day confirmation window: if both parties do not click yes within 72 hours of the confirmation email, the match is voided (src/app/api/expire-matches/route.ts:11 passes 3 to expireStaleMatches). Once the partnership is active, you can unsubscribe at any time with a single click on the footer link of any email, and the SQL UPDATE at src/app/api/unsubscribe/route.ts:59 ends all your active matches in one go. That choice, 'no minimum,' follows from the dana-tradition constraint: the service is free, so there is no floor to protect.

Why is the agreement enforced by code instead of by signatures?

Because the partnership is daily, and signed documents are a human ritual with a once-at-the-start cadence. A signed agreement works well for things that happen infrequently (a lease, a job offer, a coaching contract). It does not work well for things that happen 300 times a year. For a daily practice the enforcement that matters is, 'the thing that should fire today, fired.' A daily calendar event firing is an enforcement. A meet_clicks row being written is an enforcement. A cron job expiring a confirming match after 3 days is an enforcement. None of those are signatures, but all of them make 'yes this is happening' or 'no this is no longer happening' legible to the runtime without human intervention. The result is an agreement whose day-to-day health is measurable, not declared.

Can I see the actual text of each clause?

Yes, the whole repo is public. The cadence clause is one line: src/lib/google-meet.ts line 75, recurrence: ['RRULE:FREQ=DAILY']. The permanence clause is one sentence in the intro email template: src/lib/emails.ts line 288, 'This link is permanent, use it every day, at any time.' The 3-day window clause is the italicized sentence on the confirmation email: src/lib/emails.ts line 376, 'This match expires in 3 days. If neither of you responds, you'll both be placed back on the waitlist for a new match.' The heartbeat clause is the INSERT at src/app/meet/[token]/route.ts lines 26 to 29. The exit clause is the UPDATE at src/app/api/unsubscribe/route.ts line 59. The no-repeat clause is the filter at src/app/api/auto-match/route.ts lines 241 to 245. The pre-existing-condition clause is the paragraph on src/app/disclaimer/page.tsx lines 60 to 73. Nothing is hidden.

Where does this leave anything about meditation technique?

Out of scope, by design. The agreement described on this page is entirely about the partnership infrastructure: who meets whom, when, over which link, for how long, and how exit works. It does not cover anything about how to practice, how to sit, or how to handle what arises in a session. For those questions, the only honest redirect is to dhamma.org and to an authorized assistant teacher at a 10-day residential course. The runtime here has no opinion about your sits and no way to coach you through one. It has an opinion about whether the Meet URL is getting clicked.

Related pages on the same topic

How did this page land for you?

React to reveal totals

Comments ()

Leave a comment to see what others are saying.

Public and anonymous. No signup.