Skip to main content
Glama

Server Details

Books your AI keeps from your own bank statements: cards, loans, bills, receipts and the tax year.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
Repository
alviso/saybooks
GitHub Stars
0
Server Listing
Saybooks
ChatGPT
–
Claude
–

TDQS

B3.2/5.0

Scored across 236 tools

Disambiguation3/5

The module prefixes (o2c_, purch_, crm_, gl_, etc.) give strong top-level separation, and within each module the verbs are sharply distinct (e.g. o2c_confirm_order vs o2c_amend_order). But across modules there are near-parallel surfaces an agent must choose between — solo_draft_invoice/solo_record_payment/solo_apply_payment vs o2c_create_order/o2c_record_payment/o2c_apply_payment, core_create_customer vs crm_promote_to_customer, core_receive_stock vs p2p_receive_goods vs inv_count_stock, and core_journal vs bridge_preview/bridge_export — so selection depends on knowing which module the workspace has mounted, not on the tool names alone.

Naming Consistency4/5

Overwhelmingly consistent module_verb_noun snake_case (crm_add_account, purch_review_transaction, gl_record_entry, loan_link_payment), with predictable read/write pairs like purch_bills/purch_get_bill and rec_match/rec_unmatch. The only deviations are noun-only listers and getters such as core_schema, purch_accounts, purch_vocabulary, tax_return and purch_spend, which are readable but break the strict verb_noun pattern.

Tool Count1/5

236 tools is an extreme surface for a single connector, far past any practical selection budget for an agent. Even if a given workspace only mounts a subset, the exposed list is enormous and forces the agent to discover state and commands via core_schema/core_setup_status rather than from the tool list, which is itself a symptom of over-scoping.

Completeness5/5

Coverage is exceptional across every named domain: order-to-cash (quote, order, ship, invoice, payment, credit note, return, refund, write-off, void), procure-to-pay (PO, receipt, bill, match, tolerance), GL close/adjusting entries, inventory valuation and counts, bank/statement review and reconciliation, loans, CRM, job hunt, prospect imports, sales tax filings, and freelancer invoicing. Gaps that exist are deliberate and stated (no outbound channel, no payment un-application, human-only sign-offs), so an agent is never left without a documented next step.

Publisher details

Operator
Crankk Inc
Operator website
https://saybooks.io/
Vendor relationship
Not applicable
Privacy policy
Not provided
Trust center
Not applicable
Restrictions
No setup restrictions

Available Tools

236 tools
bridge_accountsAccount mapA
Read-onlyIdempotent
Inspect

Our fixed derivation accounts, which ones the books use, and what each is called in the ledger of record. Read this before any export. Anything in use and unmapped is a question for the person or their accountant, never a guess.

Inputs: no named parameters.

bridge_exportExport to the ledgerAInspect

Hand the period over: build the file in the ledger's shape, record what went out, and return a download link. Show the person bridge_preview and its totals first; this is the act that says the period has been handed over. Omit "from" to continue from the last hand-over in this format — month-end becomes a diff, not a re-key. Refused while an account the period uses is unmapped, naming which. Hand over the returned link; never relay the file's bytes. The file is kept exactly as it went out, with its control totals and a hash, so a later question about what the ledger received has an answer. Effects: journal file built for the period; hand-over recorded with its control totals; download link minted.

Inputs: to (required), format (required), from, reason, +1 more.

bridge_exportsHand-oversA
Read-onlyIdempotent
Inspect

What has been handed to the ledger, in which shape, through when — with the totals and the file that went out. The answer to "did the ledger get August?". Each row keeps its control totals and a hash of the exact file; the link re-downloads that file, not a fresh derivation.

Inputs: no named parameters.

bridge_financialsPreliminary financialsA
Read-onlyIdempotent
Inspect

A profit and loss for a period and a balance sheet at its end, derived from the books and marked preliminary, with everything they leave out said on their face. For "how did we do this quarter", "generate preliminary Q1 financials", or a number for the accountant before the close. Pass the period as a quarter (2026-Q1), a month (2026-09), a year, or from and to. Say "preliminary" when you present it, and read the notes out: rows not reviewed yet are not in the figures, and a transfer account the books cannot classify is a question for the person (savings, owner draw, or a loan or card). Do not round, restate or "fix" the figures; if they look wrong, the fix is in the books (review the rows, name the transfer), and the statements follow. One currency at a time.

Inputs: to, from, period, currency.

bridge_map_accountMap an accountA
Destructive
Inspect

Say what something is called in the ledger of record: one of our accounts, or one of the person's own spending categories or statement accounts. The mapping is the accountant's answer, not a guess: ask for the code and the name exactly as their chart spells them, one at a time, and write them as they are given. Xero imports match on the code, QuickBooks on the name, so supply both where you can.

Three kinds. "derivation" is one of our fixed accounts (receivables, revenue, cash, bank fees). "category" is a word the person used when reviewing their spending — groceries, software, rent — and it needs their expense or income account. "source" is the account a statement came from, their bank or card, and it needs that account in the chart. bridge_accounts lists all three and says which are in use. The tax rate label is only needed where their import expects one. Changing a mapping never rewrites a hand-over that already went out. Effects: account mapping written.

Inputs: account (required), code, kind, name, +3 more.

bridge_previewPreview the hand-overA
Read-onlyIdempotent
Inspect

The journal for a period in the ledger's shape, with control totals and anything still unmapped. Records nothing. Show the person the totals and the first rows before bridge_export. Omitting "from" previews what has not been handed over yet in that format.

Inputs: to (required), format (required), from, rows, +1 more.

core_auditAudit trailA
Read-onlyIdempotent
Inspect

What happened, who did it, and whether it was a person or an agent. Includes refused commands. Both surfaces write here. actor_kind "agent" means a model called the tool; "human" means somebody clicked. Refusals are kept — a blocked agent action is exactly what you want to be able to review.

Inputs: limit, subject_id.

core_company_profileCompany profileA
Read-onlyIdempotent
Inspect

The business's own identity as it prints on documents: seller block, tax id, payment instructions.

Inputs: with_logo.

core_create_customerNew customerAInspect

Create a customer we can sell to. A credit limit of 0 means prepay only — that is a real position, not a missing value. Do not invent a limit to make an order go through; if the limit is wrong, someone with the authority to change it changes it, and that change is its own logged command. Effects: customer created.

Inputs: name (required), email, terms, tax_id, +2 more.

core_create_itemNew itemAInspect

Create a sellable item. Set stocked=false for services and anything that cannot run out; those lines never check inventory and never deplete it. Effects: item created.

Inputs: sku (required), name (required), unit_price (required), on_hand, +2 more.

core_get_customerCustomerA
Read-onlyIdempotent
Inspect

One customer as master data: contact facts, billing address, tax id, terms, hold state. (o2c adds the live credit position in o2c_get_customer.)

Inputs: customer_id (required).

core_hold_customerCredit holdA
Destructive
Inspect

Put a customer on credit hold: no new orders confirm until released. A hold outranks the limit: however much room the numbers show, nothing confirms while it is on. Already-confirmed orders are not touched — fulfil and bill them as agreed; the hold is about taking on NEW exposure. Holds are for judgment the formula cannot see: a bounced check, a dispute turning sour, news about the customer. Effects: customer.on_hold set; o2c_confirm_order refuses while held.

Inputs: reason (required), customer_id (required).

core_inviteInvite memberA
Destructive
Inspect

Share this workspace: by email (they sign in with Google) or as a member token (a link that is the key). The link is the key: whoever opens it works here under that name and role, and every act they (or their agent) take is attributed to that name. Roles: owner (everything), controller (everything but workspace admin), clerk (day-to-day, no credit authority), viewer (read only). Denials are one-sentence refusals, logged — attempted overreach is reviewable, like everything else. Effects: member token minted.

Inputs: name (required), role (required), email.

core_journalJournalA
Read-onlyIdempotent
Inspect

Double-entry journal lines derived from the books, for export to the ledger of record. Nothing here is posted or stored — re-derivation is the truth. Fixed accounts; a voided invoice contributes nothing (INV-23). Revenue side only: items carry no cost, so there are no COGS or inventory entries — the ledger of record owns inventory and margin. The ledger of record stays wherever it is.

Inputs: to, from, currency.

core_membersMembersA
Read-onlyIdempotent
Inspect

Who has access: email members (Google sign-in) and token keys (agents, link shares).

Inputs: no named parameters.

core_next_actionsWhat can I do nowA
Read-onlyIdempotent
Inspect

The commands available on an entity right now, and for the rest, the business reason they are not. This is the same evaluation that decides which buttons are live in the UI. Prefer it over guessing at a state machine, and quote the reason back verbatim when something is blocked — it is written to be shown to a person.

Inputs: id (required), subject_type (required).

core_receive_stockReceive stockA
Destructive
Inspect

Increase quantity on hand for a stocked item. Receipts are additive and never retroactive. To correct a count, receive the difference — a negative qty is allowed for that and is visible as a correction in the log. Effects: item.on_hand adjusted.

Inputs: qty (required), item_id (required), note.

core_release_customerRelease holdA
Destructive
Inspect

Release a customer from credit hold. The release is its own logged act with its own reason — "who released it and why" is exactly the question that gets asked later. The limit applies again from the next confirmation. Effects: customer.on_hold cleared.

Inputs: reason (required), customer_id (required).

core_replay_scenarioReplay scenarioA
Destructive
Inspect

Replay one spec scenario live in its scratch workspace and return the step-by-step evidence. A replay is not a simulation: the scenario runs through the real registry — same guards, same audit trail — in a throwaway workspace, and the response walks every step: act, command, arguments, expectation, and what actually came back. Show it to someone learning the area; the refusal steps teach more than the happy path. Refreshes the persisted evidence. Effects: scratch workspace wiped and scenario replayed; conformance evidence refreshed.

Inputs: file (required), area.

core_reset_workspaceReset workspaceA
Destructive
Inspect

Wipe THIS workspace and optionally reseed it from a named fixture. Destroys every row in the current workspace — yours, nobody else's. Available only outside production. Fixtures are command scripts (fixtures/.json), so a reseeded workspace has a real audit trail: every seed row shows as a logged command by actor "fixture". Effects: all rows in this workspace deleted; fixture commands replayed if given.

Inputs: fixture.

core_revoke_memberRevoke memberA
Destructive
Inspect

Revoke a member's token. Their link stops working immediately. Revocation is a logged act like any other; the member's past entries in the trail keep their name. Nothing is deleted. Effects: member token revoked.

Inputs: name (required).

core_schemaSchemaA
Read-onlyIdempotent
Inspect

The shape of the system: modules, entities, lifecycles, the encoded rules, and every command. Call this first in a new session. It is cheaper than guessing, and it is generated from the same registry the tools come from — so the SERVER cannot serve a stale one. Your client can: connector tool lists are cached by the app when the connector is added. If a command listed here is missing from your tools, or a tool has fewer arguments than this schema says, remove and re-add the connector and start a new chat. This schema is the truth; the tool list is a cache of it.

Inputs: no named parameters.

core_set_company_profileSet company profileA
Destructive
Inspect

The business's own identity: seller block, tax id, payment instructions, country, currencies, tax scheme, numbering. One per workspace. The invoice document's seller comes from here — a document without it is incomplete, not wrong (INV-22). Patch semantics: only the fields you pass change; the name is required only the first time. Effects: company profile written.

Inputs: name, tax_id, address, country, +9 more.

core_set_credit_limitSet credit limitA
Destructive
Inspect

Change how much unpaid exposure we will carry for a customer. This is the human decision the credit gate's refusal points to. When o2c refuses to confirm an order, the answer is never to route around the gate — it is for someone with the authority to change this number to change it, here, with a reason that will be read back. A limit of 0 means prepay only. Lowering a limit never touches already-confirmed orders; it tightens the gate for the next one. Effects: customer.credit_limit changed for future confirmations.

Inputs: reason (required), customer_id (required), credit_limit (required).

core_set_priceSet list priceA
Destructive
Inspect

Change an item's list price. Takes effect for documents raised from now on. Everything already raised keeps the price it was raised with — a quote accepted after this change still becomes an order at the quoted price (INV-19), and issued invoices never move. That is why this is a logged act and not a field edit: the moment the price changed is part of the record. Effects: item.unit_price changed for future documents only.

Inputs: item_id (required), unit_price (required).

core_setup_statusSetup checklistA
Read-onlyIdempotent
Inspect

Is this space ready to invoice, and if not, the next question to ask — in order. Call this FIRST in a space you have not seen before, before core_schema's details matter. It lists what the company profile still needs, in the order to ask: name, country, currency, tax scheme, address, payment instructions; then the optional numbering format and logo; then a first client.

WHAT THE PERSON ALREADY TOLD YOU, WRITE NOW. If their message carried the name, the country, the currency or the tax position, call core_set_company_profile with all of it in one go before asking anything. 'ask' is the question for something still MISSING after that; asking a person for a fact they gave you a moment ago is the fastest way to lose them. Ask ONE question at a time, in this order, only for what is genuinely missing, and write each answer as you get it. Country comes first because it decides how dates and amounts print; tax must be ANSWERED (registered yes or no) — the default is not an answer. Nothing here is needed for a job-hunt space.

Inputs: no named parameters.

core_spec_statusSpec statusA
Read-onlyIdempotent
Inspect

Implementation status against the area spec: acts, scenarios with evidence, invariants with what exercises them. The answer to "how far along is the spec, and how do you know". Derived, never asserted: acts come from the implements map, evidence from the last conformance run. Use it to teach — each scenario's steps show the act, the doctrine, the arguments, and what came back, refusals included; refusals are half the curriculum.

Inputs: area.

core_update_customerUpdate customerA
Destructive
Inspect

Change a customer's contact facts: email, billing address, tax id, terms. Patch semantics: only the fields you pass change. These are the customer's own facts — ask, never guess an address. Credit limit and hold have their own commands because they are authority, not contact details. Issued documents keep the bill-to block they were issued with. Effects: customer record updated.

Inputs: customer_id (required), email, terms, tax_id, +1 more.

core_workspacesWorkspacesA
Read-onlyIdempotent
Inspect

List the workspaces on this deployment and which one this session is in. On a hosted demo this answers with your sandbox only: a sandbox name is the key to that sandbox, so other visitors' names are never listed.

Inputs: no named parameters.

crm_add_accountNew accountAInspect

Add a researched account to the list. The gate to the list (CRM-3): why_them and source_url are mandatory, because this is a curated list, not a funnel — its value is that every row can say why it belongs and where that knowledge came from. If you cannot say why them and what changed, it is not a target yet. Effects: account created in not_started.

Inputs: name (required), why_them (required), source_url (required), campaign_id (required), +5 more.

crm_add_contactAdd contact (CRM)AInspect

Record a person at an account — named with a source, or as a gap. Two shapes, nothing in between (CRM-1, CRM-2). Named: name + source required — a name without a source is not usable in a first approach, so it is refused, not warned about. Gap: no name, gap_note required — the role exists and its holder is not publicly known, and that absence is a finding worth recording. Guessing is the only real failure here. Effects: contact created as named or gap.

Inputs: role_type (required), account_id (required), name, email, +7 more.

crm_add_eventAdd eventAInspect

Put something that is going to happen on an account: a workshop, a call, a deadline. With the source the date came from. NEVER INVENT A DATE (CRM-20). The date on an event comes from the source, and the source is a field here because it will be read back by the person deciding whether to turn up.

A page that lists dates in one column and topics in another, without pairing them, HAS NOT GIVEN YOU A DATE for any topic. Reading one off by position is how a first approach ends: a message to the person who owns the curriculum, naming a day they never published. If the source does not pin the date, there is no event; tell your human what you found and where, and let them decide.

The source is a URL when you found it, or "told by on " when a person told you. An event nobody can trace is a diary entry, not a record.

Use contact_id when the event is with, or run by, a specific person on the account. The account is enough for a public workshop. The note is why this is worth their time: what it opens, who will be there, what to do about it beforehand. Effects: event recorded as planned, with its source.

Inputs: date (required), title (required), source (required), account_id (required), +6 more.

crm_attend_eventAttendanceA
Destructive
Inspect

Record where you stand on an event: not attending, attending, registered, or went. One word, no form. Whether an event happens is the organiser's business; whether your human goes is theirs (CRM-22). Most events here were found, not scheduled, so this is the verb that fits them: skip, attending, registered, or went.

ONLY ON YOUR HUMAN'S WORD. You have no source for whether a person intends to turn up except that person. If they said it, record it; if they did not, ask.

"went" is for after the date. An event with attendance went and no outcome is the one the calendar asks about afterwards: what came of it goes on the event with crm_update_event. Effects: attendance recorded on the event.

Inputs: event_id (required), attendance (required).

crm_calendarCalendarA
Read-onlyIdempotent
Inspect

What is coming, by day, and every planned event that already passed with no outcome recorded. Default window is today to a year out, and planned_after_window says what even that hides. awaiting_outcome is the list to read first: something your human meant to attend whose date has gone by with no word since. Ask what came of it, then settle it with crm_attend_event and crm_update_event.

Inputs: to, from, status, account_id.

crm_campaignsCampaignsA
Read-onlyIdempotent
Inspect

Every campaign with its goal, status, and health: accounts by status, open gaps, staleness — the per-goal Today. Read the goal before adding accounts to a campaign — every why_them argues against it (CRM-13).

Inputs: no named parameters.

crm_coverageCoverageB
Read-onlyIdempotent
Inspect

List health: accounts by status and tier, open gaps, and accounts going stale (no activity in 14 days).

Inputs: campaign_id.

crm_create_campaignNew campaignAInspect

Open a campaign: a named goal that accounts will be pursued under. The goal is required (CRM-13) and it is not a label — it is the brief. A research session reads it before adding a single account, and every account's why_them must argue against it. A campaign without a stated thesis is a folder, not a pursuit.

Check crm_campaigns before creating: if an existing goal covers the ask, work under it. When you (an agent) open a NEW campaign, derive the goal from what your human asked for and confirm it with them before filling the list — the goal decides what belongs. Effects: campaign created as active.

Inputs: goal (required), name (required), target_profile.

crm_draft_messageDraft a messageAInspect

Write a message to a contact for a person to read, edit and send from their own mailbox. Nothing is sent. THIS SYSTEM HAS NO OUTBOUND CHANNEL (CRM-14). You write; a person reads it, edits it, sends it themselves, and records that it went. Never tell anyone a message was sent.

USE ONLY WHAT IS IN THE RECORD (CRM-10). The account's hook, trigger_event and path_in bullets; the contact's name and title. Never a fact about the person or the company that is not on file. If the record is thin the draft is short, not padded.

READ THE CAMPAIGN'S CLAIMS FIRST (crm_get_campaign). They are the things this business has decided it may assert about itself, written by a person. Anything beyond them is your invention, and the refused list is checked against your words at write time — but the list cannot catch an overstatement of a claim that is itself allowed, so stay inside what the claim actually says.

RATIONALE IS FOR THE REVIEWER AND IS NEVER SENT (CRM-16): which hook or bullet the angle rests on, why this contact rather than another at the same account, and anything you were unsure about. A draft with no rationale is a draft nobody can check.

Only named, live contacts. A gap row has no name to write to, and a departed contact has left. Check crm_drafts before writing a second message to someone who already has one waiting. Effects: draft recorded against the contact, unsent.

Inputs: body (required), rationale (required), contact_id (required), channel, +1 more.

crm_draft_outcomeWhat happened to a draftA
Destructive
Inspect

Record that a person sent a draft, or that they rejected it. Sending happens in their mailbox; this records it. SENT: the person sent it themselves and is telling you so. sent_at is when it actually went, which is not when this got typed (CRM-5). The draft's exact text is copied onto the activity trail as the record of what reached a real person, and the draft becomes immutable from that moment (CRM-15). An account still sitting at not_started or researching moves to approaching, because it has now been approached — that is a fact, not a forecast.

DISCARDED: a person read it and said no. rejected_because is for whoever writes the next one, so "too long, and it opened on us rather than on them" is worth typing and "no" is not.

Never record a send you were told about by nobody. If you did not hear it from your human, ask; a send that did not happen is the one fact in this system that can embarrass a person in front of a stranger. Effects: draft closed as sent or discarded; a sent draft is copied onto the activity trail; account moved to approaching on first send.

Inputs: outcome (required), draft_id (required), sent_at, rejected_because.

crm_draftsDraftsA
Read-onlyIdempotent
Inspect

Messages written but not sent, with the contact and account behind each. Check before writing a second one to somebody who already has one waiting. Nothing in this list has been sent, because this system has no way to send anything (CRM-14). status="sent" is the record of what a PERSON sent and told us about, with the exact words that reached somebody; status="discarded" is what a person read and rejected, and the reason is the most useful thing in the list when you write the next one.

Inputs: limit, status, account_id, contact_id.

crm_gapsGapsB
Read-onlyIdempotent
Inspect

Every unresolved gap with its note and age — what we verifiably do not know, as a worklist. This view existing is the point of CRM-2: the unknowns are work items, not blank cells nobody looks at.

Inputs: campaign_id.

crm_get_accountAccountB
Read-onlyIdempotent
Inspect

Full account: narrative with sources, path-in plan, contacts including gaps, recent activity, and what can be done next.

Inputs: account_id (required).

crm_get_campaignCampaignB
Read-onlyIdempotent
Inspect

One campaign: goal, status, and health.

Inputs: campaign_id (required).

crm_get_contactContact (CRM)C
Read-onlyIdempotent
Inspect

One person: identity, provenance, gap state, the activity that touched them.

Inputs: contact_id (required).

crm_list_contactsContacts (CRM)B
Read-onlyIdempotent
Inspect

Every contact across accounts — named and gaps — with provenance and the human-entered network fields.

Inputs: status.

crm_log_activityLog activityAInspect

Record a touch: what happened, when it actually happened, with whom. occurred_at is when it happened, which is not when it got typed (CRM-5) — a call logged three days late is still a call from three days ago, and staleness math depends on the truth. Interpretation in the summary is yours to write freely; facts inside it trace to sources (CRM-10). Effects: activity recorded.

Inputs: summary (required), account_id (required), occurred_at (required), medium, +2 more.

crm_pipelinePipeline (CRM)A
Read-onlyIdempotent
Inspect

Accounts by status and tier with stage probabilities — the weighted where-are-we view. Filter by campaign or see everything.

Inputs: campaign_id.

crm_promote_to_customerPromote to customerA
Destructive
Inspect

Create the core customer from a won account — the bridge from pursuit to trading. Won accounts only, at most once (CRM-8): a second customer for the same account would be a reconciliation problem wearing a convenience. Creation goes through core's API — one logged act marking where this area's job ends and order-to-cash begins. The account keeps its whole pursuit history; the customer starts clean. Effects: core customer created; account.customer_id linked.

Inputs: account_id (required), email, terms, credit_limit.

crm_resolve_gapResolve gapA
Destructive
Inspect

Turn a gap into a named contact — with full provenance. The only way a gap becomes named (CRM-2), and it demands the same provenance as a fresh contact — the gap does not lower the bar. The gap_note stays on the row: what we did not know is part of how we came to know it. Effects: contact gap -> named.

Inputs: name (required), source (required), contact_id (required), email, +4 more.

crm_set_account_statusMove statusA
Destructive
Inspect

Move an account along the pursuit lifecycle. Parking or killing a researched account requires a reason (CRM-7) — on_hold, closed and excluded all carry prose that will be read back. won, closed and excluded are terminal: nothing is deleted, and nothing quietly comes back either (CRM-6). Re-pursuing a closed account is a new decision — say so in a fresh why_them via update, then reopen deliberately is not offered: add it again the day it genuinely earns a new place. Effects: account.status moved, reason kept.

Inputs: status (required), account_id (required), reason.

crm_set_campaign_statusCampaign statusA
Destructive
Inspect

Pause, resume or conclude a campaign. Pausing and concluding require a reason — a goal someone stops pursuing is a decision that gets asked about later (CRM-7 extended). Concluded is terminal: the accounts stay fully readable (CRM-6), but the campaign takes no new targets. Effects: campaign.status moved, reason kept.

Inputs: status (required), campaign_id (required), reason.

crm_set_path_inSet path inA
Destructive
Inspect

Replace the ordered "how we get in" plan for an account. The bullets replace the previous set whole — a plan is one coherent thing, not a pile of appended thoughts. The old plan stays in the audit trail. Effects: path-in bullets replaced.

Inputs: bullets (required), account_id (required).

crm_todayTodayA
Read-onlyIdempotent
Inspect

The CRM work queue: open gaps, accounts going stale, and what happened lately. Three lists, one question: what deserves attention today. Gaps are research work; stale active accounts are follow-up work; recent activity is context.

Inputs: no named parameters.

crm_update_accountUpdate account (CRM)A
Destructive
Inspect

Correct or deepen the account narrative. Only the fields you pass change. Provenance survives updates (CRM-9): why_them and source_url can be corrected, never blanked. Status moves have their own command, with its own rules.

PARKING IS NOT A STATUS MOVE (CRM-18). status is a judgement about where a pursuit sits; parking is a fact about what happened to it — both intake routes dead, the sponsor left, a reorganisation in flight. An account parked at researching is still at researching, and says why nobody is spending time on it. Parking needs a reason, is reversible with park="", and takes the account out of the worklists until it comes back. Effects: account narrative updated; account parked or unparked, with the reason kept.

Inputs: account_id (required), hook, name, park, +6 more.

crm_update_campaignUpdate campaignA
Destructive
Inspect

Sharpen a campaign. The goal can be corrected, never blanked. Same rule as provenance (CRM-9 in spirit): the goal is load-bearing — sharpen it freely, remove it never.

CLAIMS ARE HUMAN-ONLY (CRM-17). claims_allowed is what this business has decided it may say about itself; claims_refused is the words and phrases no draft on this campaign may contain. Both are typed by a person, and both replace the previous list whole. Agents read them before drafting (crm_get_campaign) and are refused at write time by the second list, but the gate cannot catch an overstatement of a claim that is itself allowed — so a draft has to stay inside what the claim actually says, not merely mention the same subject. Effects: campaign updated; claim lists replaced when passed.

Inputs: campaign_id (required), goal, name, claims_allowed, +2 more.

crm_update_contactUpdate contact (CRM)A
Destructive
Inspect

Correct or extend a contact. The relationship-graph fields are human-only. Ordinary fields are open: titles change, confidence firms up, people depart (status=departed — never deleted, CRM-6). Provenance is correctable, never removable (CRM-9). mutual_via, mutual_url and linkedin_path are entered by a person, never an agent — ask your human to fill them in; that is correct behavior, not a limitation to route around. Effects: contact updated.

Inputs: contact_id (required), name, email, notes, +9 more.

crm_update_draftRewrite a draftA
Destructive
Inspect

Rewrite a draft that has not been sent. Pass only what changes. USE THIS WHEN THE ANGLE CHANGES rather than discarding and starting again: a better hook turns up, the trigger event moves on, your human asks for a different opening. Discarding loses the rationale and the record of what was already tried on this contact.

A SENT DRAFT CANNOT BE TOUCHED (CRM-15). Its text was copied onto the activity trail as the record of what actually reached a real person, and rewriting it would leave these books describing a message nobody sent. Write a follow-up instead.

A DISCARDED DRAFT CANNOT BE REVIVED. A person read it and rejected it; bringing it back would quietly overturn that decision. Write a fresh one and say in the rationale what changed.

An edit goes through the same claim gate as a new draft: an edit cannot smuggle in what the first write would have stopped. The draft stays a draft, so a person still reads it. Effects: draft text replaced; it remains unsent.

Inputs: draft_id (required), body, subject, rationale.

crm_update_eventUpdate eventA
Destructive
Inspect

Reschedule, correct, close as done with what came of it, or cancel with a reason. A move of the date needs a reason and a source, the same as the date did the first time: "the venue page now says the 14th" is a reason; "moved" is not. Done takes an outcome, because an event with no outcome is an intention that went stale. Cancelled takes a reason. Neither is undone here (CRM-21): if a cancelled thing is happening after all, that is a new event with a new source. Effects: event rescheduled, corrected, done or cancelled; the reason kept.

Inputs: event_id (required), url, date, note, +8 more.

gl_changesChanges after closeB
Read-onlyIdempotent
Inspect

What the record now says differently about closed periods, per account, landing on the first open day.

Inputs: no named parameters.

gl_checklistClose checklistA
Read-onlyIdempotent
Inspect

What blocks closing the books through a day (unreviewed statement rows, accounts that do not tie), and what is open but not blocking.

Inputs: through (required).

gl_close_periodClose the booksA
Destructive
Inspect

Close the books through a day: the period's journal is kept as it stands, and its figures stop moving. Later changes land as corrections in the next open period. HUMAN-ONLY: this act is refused to you whatever your role — Closing the books is the person's or the accountant's sign-off on what the period says. Ask your human to do it. Refused to you whatever your role. Show the person the checklist (gl_checklist): what blocks the close and what is open. They close it in the app. Effects: period closed; its journal kept with its totals and a hash.

Inputs: reason (required), through (required).

gl_closesClosesB
Read-onlyIdempotent
Inspect

Every close: through when, by whom, its totals and hash, and whether the record has changed since.

Inputs: no named parameters.

gl_entriesAdjusting entriesA
Read-onlyIdempotent
Inspect

Adjusting entries, newest first, with their lines and any reversal.

Inputs: no named parameters.

gl_entryAdjusting entryC
Read-onlyIdempotent
Inspect

One adjusting entry with its lines.

Inputs: entry_id (required).

gl_record_entryNew adjusting entryAInspect

An adjusting entry for the close: an accrual, depreciation, a correction. Balanced, dated in an open period, with a reason. An accrual can reverse itself on the 1st of the next month. Adjusting entries are the accountant's tool: record them when the accountant or the person gives the figures, never invent an amount. Each line names an account in their words and says what kind it is (asset, liability, equity, income, expense), with a debit or a credit; the entry must balance. Mark an accrual to reverse (reverse: true) so it undoes itself on the 1st of the next month, when the real bill or payment arrives. A period that is already closed takes no entries: date it in the open period. Effects: adjusting entry recorded; its reversal on the 1st of the next month, when marked.

Inputs: date (required), memo (required), lines (required), reason (required), +1 more.

gl_reopen_periodReopen the latest closeA
Destructive
Inspect

Reopen the most recent close, with a reason. Its period moves again with the record; the close stays on the record as reopened. HUMAN-ONLY: this act is refused to you whatever your role — Reopening a closed period undoes a sign-off; a person decides that, with a reason. Ask your human to do it. Refused to you whatever your role. Only the latest close can be reopened; earlier ones stay closed. Effects: latest close reopened.

Inputs: reason (required).

gl_void_entryVoid entryA
Destructive
Inspect

Void an adjusting entry in an open period, with a reason. It stays on the record as voided. Only while its period is open. In a closed period, record the opposite entry in the open period instead. Effects: entry voided.

Inputs: reason (required), entry_id (required).

hunt_add_contactAdd contact (job hunt)AInspect

Add a person. A source is mandatory — how we know them. Never invent a contact (JH-2). The source is the answer to "how do we know this person" — a recruiter who reached out, a referral, a name from an email thread. Effects: contact created.

Inputs: name (required), source (required), role, email, +6 more.

hunt_add_interviewAdd interviewA
Destructive
Inspect

Record a scheduled round. Moves the application to interviewing. Rounds are facts with outcomes (JH-12). The round number defaults to the next. Effects: interview round recorded; application -> interviewing.

Inputs: application_id (required), kind, notes, round, +2 more.

hunt_add_postingNew postingAInspect

Record a JD encountered. Runs the duplicate guard; its warnings ride the result. Facts come only from the JD or actual correspondence (JH-1). The company is created by name if new; for agency postings, get the end client — the guard keys on it, and the same req arriving through four agencies is normal (JH-3). The warnings in the result are for a PERSON to act on: never silently merge, never quietly drop — a double submission can disqualify the candidate. Effects: posting created as lead; duplicate warnings surfaced in the result.

Inputs: title (required), company (required), url, req_id, +11 more.

hunt_add_resume_versionRegister resume versionCInspect

Register a resume version so applications can point at what was actually sent. When a recruiter says "the resume you sent", there must be exactly one answer (JH-10). Effects: resume version registered.

Inputs: label (required), focus, notes, headline, +3 more.

hunt_applyApplyA
Destructive
Inspect

Record an application actually submitted. One per posting. One application per posting (JH-4) — the duplicate guard exists so the SAME role through two agencies gets a decision, not two submissions. applied_at accepts the literal "unknown" when the submission is real but the date was never recorded — never guess a date (JH-1). Record the resume version that actually went out (JH-10). Effects: application created; posting -> applied; submission logged as a touch.

Inputs: posting_id (required), channel, applied_at, via_contact, +1 more.

hunt_check_duplicatesCheck duplicatesA
Read-onlyIdempotent
Inspect

The duplicate guard as a pure read: check a JD before adding it. Records nothing. Warnings are for a person to weigh (JH-3). The same req via several agencies is normal; the double submission is the disqualifier.

Inputs: title (required), url, req_id, company, +3 more.

hunt_complete_next_actionComplete next actionB
Destructive
Inspect

Close the open next action once handled. With direction and medium it counts as a real touch; without them it is an internal note that triggers no follow-up nudge — the honest difference between "I emailed them" and "I decided it is done". Effects: open next action -> done; a touch logged.

Inputs: note, medium, direction, posting_id.

hunt_contactsContacts (job hunt)C
Read-onlyIdempotent
Inspect

People with relationship, source, and last touch.

Inputs: relationship.

hunt_correct_applicationCorrect recordA
Destructive
Inspect

Correct applied_at or the submission route (via_contact) when the true facts surface. The reason is part of the record. A correction replaces "unknown" or a wrong value with a sourced fact — never a guess (JH-1). Say where the fact came from; a corrected date re-dates the submission touch to match. Effects: application facts corrected; submission touch re-dated when the date moves.

Inputs: reason (required), application_id (required), applied_at, via_contact.

hunt_dueDueA
Read-onlyIdempotent
Inspect

What needs attention: overdue and upcoming next actions, follow-up nudges, suggest-ghosted, stale leads, missing end clients, upcoming interviews. Everything here is a suggestion (JH-7). The system never sends, submits, or clicks — it records and reports.

Inputs: horizon_days.

hunt_evaluate_postingEvaluateA
Destructive
Inspect

Record the evaluation — or the skip, with its reason. Skips are pattern memory (JH-8): a skip_reason is required to skip, and skipped postings stay queryable — which agencies waste your time is knowledge. Effects: posting -> evaluated, or skipped with reason.

Inputs: posting_id (required), fit_notes, fit_score, red_flags, +2 more.

hunt_get_contactContact (job hunt)C
Read-onlyIdempotent
Inspect

One person whole: identity, provenance, relationship, the postings they touch, full touch history.

Inputs: contact_id (required).

hunt_get_postingPostingA
Read-onlyIdempotent
Inspect

One posting whole: facts, evaluation, application, interviews, touch history, open next action.

Inputs: posting_id (required).

hunt_get_resumeResume versionA
Read-onlyIdempotent
Inspect

One resume version: what it says, every application it went out on, and the postings it is earmarked for.

Inputs: resume_id (required).

hunt_interview_outcomeInterview outcomeA
Destructive
Inspect

Close a round. The outcome is a touch in the history (JH-12). Outcomes are facts: passed, failed, rescheduled, or their no-show. Close the round when you know; the notes carry the interpretation. Effects: interview outcome set; touch logged.

Inputs: outcome (required), interview_id (required), notes.

hunt_log_interactionLog touchA
Destructive
Inspect

The workhorse: record any touch, optionally with the next action and its due date. Direction matters: follow-up nudges key on real outbound touches. A next_action supersedes the posting's previous open one — history kept, because what you MEANT to do is part of the record (JH-6). Facts in the summary come from real correspondence (JH-1); interpretation is yours. Effects: touch recorded; previous open next action superseded when a new one is given.

Inputs: summary (required), direction (required), at, medium, +4 more.

hunt_pipelinePipeline (job hunt)A
Read-onlyIdempotent
Inspect

The board: counts by stage first, then every non-terminal item with stage, last touch, open next action. On a long board, filter by status.

Inputs: status.

hunt_resume_versionsResume versionsB
Read-onlyIdempotent
Inspect

The registry, with how many applications each version went out on.

Inputs: no named parameters.

hunt_set_application_statusMove applicationA
Destructive
Inspect

Move an application along the pipeline. Logs a touch. Ghosted is a status, not a deletion (JH-9): silence is an outcome, and which companies go silent is pattern knowledge. Terminal states stay on the books. Effects: application status moved; touch logged.

Inputs: status (required), application_id (required), note.

hunt_update_contactUpdate contact (job hunt)A
Destructive
Inspect

Patch a contact. The source is never cleared. Relationships move (cold → contacted → responsive → warm_scout, or dead); provenance does not (JH-2). Effects: contact updated.

Inputs: contact_id (required), name, role, email, +5 more.

hunt_update_postingUpdate postingA
Destructive
Inspect

Patch a posting. Only the fields you pass change. Corrections from real sources only (JH-1). Setting the end client late is common and good — it comes off the due list (JH-5). Effects: posting updated.

Inputs: posting_id (required), url, title, req_id, +10 more.

inv_cost_of_salesCost of salesA
Read-onlyIdempotent
Inspect

Each shipment line in a period: what it sold for, what it cost at the moving average, and the margin.

Inputs: to, from.

inv_count_stockRecord a countA
Destructive
Inspect

What was counted on the shelf for one item. The difference from the record becomes a count move, valued at the average cost. Record what the person counted, never what you expect. A count needs a reason, said plainly ("three damaged in the move", "yearly count"). When the count matches the record nothing moves, and that is worth saying too. A difference is valued at the average cost of that moment and posts to Inventory Adjustments: the accountant sees it as shrinkage or a gain, never hidden in cost of sales. Effects: count recorded; the difference moves stock through core.

Inputs: reason (required), counted (required), item_id (required), counted_at.

inv_item_stockItem stockA
Read-onlyIdempotent
Inspect

One item's stock moves, newest first, with the quantity, average cost and value after each.

Inputs: item_id (required).

inv_movesStock movesB
Read-onlyIdempotent
Inspect

Every change to stock, newest first: received, shipped, returned, counted, adjusted, opening.

Inputs: limit, item_id.

inv_set_opening_costSet opening costA
Destructive
Inspect

What one unit was worth when it came in without a cost: stock on hand before these books, or a correction received by hand. Everything after it is derived. Only for stock that came in without a cost. Take the figure from a record the person has: the last supplier invoice, a stock sheet, the accountant's figure. Never estimate it yourself, and never use the selling price. It is the one cost anyone states; every other cost is derived from what was paid on purchase orders. Changing it later re-derives everything after it, so say why. Effects: opening cost stated; average cost, value and cost of goods sold re-derived.

Inputs: reason (required), item_id (required), unit_cost (required).

inv_stockStockB
Read-onlyIdempotent
Inspect

Every stocked item: on hand, average cost and value, and any stock without a cost.

Inputs: no named parameters.

inv_valuationStock valuationA
Read-onlyIdempotent
Inspect

What the stock was worth on a day, per item and in total, beside the Inventory balance the books derive for that day.

Inputs: as_of.

loan_addAdd a loanAInspect

Start a loan from the lender's figures: what was owed on a day, the rate, the monthly payment, escrow and the due day. The schedule, payoff date and interest are worked out from these. Take the figures from a lender statement or the loan papers the person hands you, and say which (source). Never fill a rate or a balance in from memory or the market. The loan gets an account in the register under its name ("Chase mortgage ending 7731"). A variable rate is outside this version: record the current rate and say so in the source. Effects: loan recorded from the lender's figures; its account added to the register.

Inputs: kind (required), name (required), source (required), balance (required), +9 more.

loan_candidatesPayment suggestionsB
Read-onlyIdempotent
Inspect

Statement rows that look like a loan payment: its amount near a due date, or the lender named. Suggestions only.

Inputs: no named parameters.

loan_getLoanB
Read-onlyIdempotent
Inspect

One loan whole: the payments with their splits, the twelve months ahead, the payoff, and the lender's figure against ours.

Inputs: loan_id (required), as_of.

loan_interestInterest paidA
Read-onlyIdempotent
Inspect

Interest, principal and escrow paid per loan in a year, from the payments' splits, saying which were split by the schedule rather than the lender.

Inputs: year.

loan_loansLoansA
Read-onlyIdempotent
Inspect

Each loan: what is owed and as of when, the rate, the next payment, the payoff date, interest this year, and whether it ties to the lender's figure.

Inputs: as_of.

o2c_accept_quoteCustomer acceptedA
Destructive
Inspect

Record customer acceptance and raise the sales order from the quoted lines. Prices copy across at acceptance and are then frozen on the order. If the list price moves tomorrow, this order keeps what was quoted — that is the whole reason the quote existed. The order arrives in draft: acceptance is the customer's act, confirmation is ours. Effects: quote.status -> accepted; draft order created with the quoted prices.

Inputs: quote_id (required), po_ref.

o2c_amend_orderAmend orderA
Destructive
Inspect

Replace the lines of a DRAFT order. Amendment exists only while the order is draft. After confirmation "what was confirmed" is a fixed fact the credit gate evaluated: the only permitted shrink is o2c_close_short, and growth is a new order. The passed lines replace all existing lines. Effects: order lines replaced.

Inputs: lines (required), order_id (required).

o2c_apply_creditApply credit to invoiceA
Destructive
Inspect

Apply some or all of a credit note to an invoice. Same bounds as cash: never more than the credit note has left, never more than the invoice still owes, never across customers. A credit note the customer wants paid out instead is a refund, not an application. Effects: application recorded; invoice.status -> paid when fully settled; credit_note.status -> settled when exhausted.

Inputs: invoice_id (required), credit_note_id (required), amount.

o2c_apply_paymentApply to invoice (order to cash)A
Destructive
Inspect

Apply some or all of a payment to an invoice. Bounded on both sides: never more than the payment has left, never more than the invoice still owes. Both refusals name the actual numbers, so the right next step is obvious.

Overpayment is real and stays as unapplied cash against the customer. Do not spread it across invoices the customer did not name. Effects: application recorded; invoice.status -> paid when fully settled.

Inputs: invoice_id (required), payment_id (required), amount.

o2c_ar_agingAR agingA
Read-onlyIdempotent
Inspect

Open receivables bucketed by days past due, with the invoice-level detail behind each bucket. The report to open when asked how the business is doing on cash. Buckets are current / 1-30 / 31-60 / 61-90 / 90+ against the invoice due date.

Inputs: as_of.

o2c_backordersBackordersA
Read-onlyIdempotent
Inspect

Every open confirmed quantity, by order, item and customer — what we owe whom. The honest ends of a backorder are fulfilment or close-short; this view is where you find the ones waiting for either.

Inputs: no named parameters.

o2c_cancel_orderCancel order (order to cash)A
Destructive
Inspect

Cancel an order that has not shipped. Once anything has shipped the order cannot be cancelled — bill it and issue a credit instead. Cancellation is not a way to make a mistake disappear; the order stays visible as cancelled. Effects: order.status -> cancelled; committed value released.

Inputs: reason (required), order_id (required).

o2c_close_shortClose shortA
Destructive
Inspect

Cancel the open remainder of a partially fulfilled order. This is how backorders die honestly: the customer is no longer owed the difference, committed credit exposure is released, and the reason is kept. Pass line ids to close only some lines; omit to close every open remainder. The fulfilled part stays exactly as it is. Effects: open quantities reduced to shipped; committed exposure released; order may derive closed.

Inputs: reason (required), order_id (required), lines.

o2c_confirm_orderConfirm orderA
Destructive
Inspect

Accept the order into the books. Runs the credit check. This is the credit gate, and it is the only one. Exposure counts open AR plus the uninvoiced value of everything already confirmed — a limit that only looks at issued invoices lets a slow biller be robbed politely.

If the check fails, that is the answer. Do not confirm around it by splitting the order, raising the limit, or invoicing early. Report the shortfall and let a human decide; a refusal recorded in the log is worth more than an order. Effects: order.status -> confirmed; value counts against the credit limit.

Inputs: order_id (required).

o2c_create_credit_noteCredit noteAInspect

Raise a credit note: the universal downward correction. Pricing errors, short-pay resolution, goodwill — anything past draft is corrected downward this way and only this way (INV-11). A credit note has its own open balance: apply it to invoices like a payment, or refund it. Standalone credits (no invoice reference) are allowed but the reason is mandatory and it will be read back. Effects: credit note raised as unapplied credit.

Inputs: kind (required), amount (required), reason (required), customer_id (required), +1 more.

o2c_create_orderNew orderAInspect

Raise a sales order directly, without a quote. Use this for repeat business and phone orders. Anything the customer negotiated should go through a quote instead, so the agreed price has a document behind it. Effects: order created in draft.

Inputs: lines (required), customer_id (required), po_ref.

o2c_create_quoteNew quoteAInspect

Draft a quote for a customer. A quote commits nothing: no stock is reserved, no credit is consumed. Omit unit_price to take the list price — that is the honest default. A discount is an explicit unit_price and shows up as a discount in the log, which is the point. Effects: quote created in draft.

Inputs: lines (required), customer_id (required), valid_until.

o2c_customer_statementCustomer statementA
Read-onlyIdempotent
Inspect

One customer, period-bounded: opening balance, invoices, credits, payments, refunds, closing balance. Balance-forward style — the document a controller sends monthly. Rendering and sending are out of scope; the content is not.

Inputs: to (required), from (required), customer_id (required).

o2c_get_customerCustomer (order to cash)C
Read-onlyIdempotent
Inspect

Customer with live credit position: limit, open AR, committed value, available.

Inputs: customer_id (required).

o2c_get_invoiceInvoice (order to cash)C
Read-onlyIdempotent
Inspect

Invoice with lines and what is still open on it.

Inputs: invoice_id (required).

o2c_get_orderOrderC
Read-onlyIdempotent
Inspect

Full order: lines, open and uninvoiced quantities, deliveries, invoices, and what can be done to it now.

Inputs: order_id (required).

o2c_invoice_shippedInvoice shippedA
Destructive
Inspect

Issue an invoice for everything shipped on this order and not yet billed. We bill what shipped, never what was ordered. That single rule is what keeps AR reconcilable: every invoice line traces to a delivery line, and an order that shipped in three parts produces three invoices, not one guess.

The due date comes from the customer's terms. Do not pass a due date; if the terms are wrong, fix the terms. Effects: invoice created; order_line.qty_invoiced increased; order.status -> closed when fully billed.

Inputs: order_id (required).

o2c_record_paymentRecord payment (order to cash)AInspect

Record cash received from a customer. Recording the receipt and deciding what it settles are two acts, and this is only the first. A payment that arrives without a remittance advice sits as unapplied cash — which is the correct state, and visible in o2c_unapplied_cash. Never guess which invoice a payment is for to make the aging look tidy. Effects: payment recorded as unapplied cash.

Inputs: amount (required), customer_id (required), method, reference, +1 more.

o2c_record_returnRecord returnA
Destructive
Inspect

Record goods coming back against an order; restock the sellable part; raise the credit note. Restock only what physically returns sellable (INV-12): lines flagged restock go back to stock through core; damaged goods are recorded but never re-enter it. You can never return more than was fulfilled, less what already came back. The credit note is valued at the charged price plus the tax as invoiced — the customer gets back what they were billed, not the list price. Effects: return recorded; sellable qty restocked via core; credit note (kind return) raised.

Inputs: lines (required), reason (required), order_id (required).

o2c_refundRefundA
Destructive
Inspect

Record money returned to the customer against an unapplied payment or credit note balance. Records the fact that money went back; actually moving it is out of scope, like every other outbound act. Bounded by the unapplied balance of the source instrument — you cannot refund what is already applied to an invoice without unwinding that application first (which does not exist yet, on purpose: reverse by credit note instead). Effects: refund recorded; source unapplied balance reduced; credit_note.status -> settled when exhausted.

Inputs: amount (required), source_id (required), source_type (required), method, +1 more.

o2c_send_quoteSend quoteA
Destructive
Inspect

Mark a quote as sent to the customer. This records that it went out. It does not send anything — this system has no outbound channel, by design. Effects: quote.status -> sent.

Inputs: quote_id (required).

o2c_ship_orderShipA
Destructive
Inspect

Record a shipment against a confirmed order. Partial shipments are normal. Omit lines to ship everything still open. Pass lines to ship part of it — a short ship is a fact, not a failure, and the order stays open for the rest.

Stock is checked per line and cannot go negative. If there is not enough, ship what there is and say so; do not silently reduce the ordered quantity, because the customer is still owed the difference and the open quantity is how anyone knows that. Effects: delivery created; order_line.qty_shipped increased; item.on_hand decreased via core; order.status -> shipped when nothing remains.

Inputs: order_id (required), lines, carrier, tracking.

o2c_unapplied_cashUnapplied cashC
Read-onlyIdempotent
Inspect

Payments received that no invoice claims yet.

Inputs: no named parameters.

o2c_void_invoiceVoid invoiceA
Destructive
Inspect

Void an invoice that should never have been issued. Only an invoice with no cash applied to it can be voided, and voiding puts the quantities back to uninvoiced so the order can be billed correctly. An invoice the customer has already paid against is corrected with a credit note, never voided — the money moved, and the record has to keep saying so. Effects: invoice.status -> void; order_line.qty_invoiced released.

Inputs: reason (required), invoice_id (required).

o2c_write_offWrite offA
Destructive
Inspect

Close an uncollectible open invoice balance as a visible, reasoned credit act. A write-off is a credit note of kind write_off, raised for the open balance and applied to the invoice in the same act — never a deletion, never silent (INV-16). The threshold for who may write off how much is yours to police; the record that it happened is not. Effects: credit note (kind write_off) raised and applied; invoice.status -> paid.

Inputs: reason (required), invoice_id (required).

p2p_bill_matchBill matchB
Read-onlyIdempotent
Inspect

The 3-way match for one bill: each line against what was received (or ordered, for services) and against the order's price, with the tolerance that applies.

Inputs: bill_id (required).

p2p_cancel_poCancel order (purchasing)A
Destructive
Inspect

Cancel an order nothing has arrived against and no bill points at. With a reason. Once anything has arrived, the order cannot be cancelled: close the rest short instead. The order stays on the record as cancelled. Effects: order cancelled.

Inputs: po_id (required), reason (required).

p2p_close_po_shortClose the rest shortA
Destructive
Inspect

Stop waiting for what has not arrived: the vendor will not send it. What did arrive stays received and billable. With a reason. Use it when the vendor says the rest is not coming. When nothing has arrived at all, cancel instead. Effects: order closed short.

Inputs: po_id (required), reason (required).

p2p_create_poNew purchase orderAInspect

Draft an order to a vendor: what, how many, at the price they quoted. A draft commits to nothing until it is issued. Use the items as they are on record (core items); the price is the vendor's price for one, as they quoted it, never the price you sell at. One line per item. Never invent a price or a quantity: ask. A draft can be cancelled and raised again; once issued, the prices are frozen and the order is what bills are matched against. Effects: purchase order created in draft.

Inputs: lines (required), vendor (required), note, currency, +2 more.

p2p_goods_receivedGoods receivedA
Read-onlyIdempotent
Inspect

What arrived, against which order, when, at the order's prices. Newest first.

Inputs: po_id.

p2p_issue_poIssue orderA
Destructive
Inspect

Record that the order went to the vendor. Its prices freeze: bills are matched against them. Issue when the person says the order went out (Saybooks sends nothing; they send it). After this the order cannot be edited, only received against, closed short or, while nothing has arrived, cancelled. Effects: order issued, prices frozen.

Inputs: po_id (required).

p2p_poPurchase orderA
Read-onlyIdempotent
Inspect

One order: each line with what was ordered, received and billed; its receipts and bills, and whether each bill matches.

Inputs: po_id (required).

p2p_posPurchase ordersC
Read-onlyIdempotent
Inspect

Orders by state, with what is still to arrive on each.

Inputs: state.

p2p_receive_goodsReceive goodsA
Destructive
Inspect

Record what arrived against an order, as counted. Stock goes up; the goods are owed for until their bill is approved. Record what was counted at the door, against the order it came on, with the packing slip number when there is one. Never receive what was not counted, and never more than is still open on a line: that is refused with the numbers, and the answer is a conversation with the vendor, not a second order. Services are not received; their bill is matched against the order. A receipt cannot be changed afterwards. Effects: goods receipt recorded; stock increased through core; order received when every stocked line has arrived.

Inputs: lines (required), po_id (required), note, reference, +1 more.

p2p_record_vendor_billRecord a bill on this orderAInspect

Record a vendor's bill against an order, line by line as printed. It is matched against what was ordered and received; a person approves paying it only when it matches. You were handed the vendor's invoice for goods on an order. Record it line by line as printed: the item, the quantity and the price for one, plus the vendor's invoice number and the dates. Never correct a line to make it match; the bill is what the vendor says, and the match exists to show where it differs. The result says whether it matches the order and, when it does not, by how much. Recording is never refused for a mismatch; approving it is. Tell the person what the match says; when it does not match, the answer is a corrected bill from the vendor (record it, and the person rejects the old one) or a person loosening the tolerance with a reason. Effects: bill recorded in Bills, waiting for approval; its lines kept for the 3-way match.

Inputs: lines (required), po_id (required), bill_date (required), number, +6 more.

p2p_set_match_toleranceSet match toleranceA
Destructive
Inspect

How far a bill may stray from its order before approval is refused: a price percentage and a quantity percentage. 0 by default. HUMAN-ONLY: this act is refused to you whatever your role — Loosening the match is a decision about how much a vendor may overcharge before a person is told no. Ask your human to do it. Refused to you whatever your role. If a bill is refused by the match, show the person the numbers (p2p_bill_match); they decide whether to loosen it. Effects: match tolerance set.

Inputs: reason (required), qty_pct, price_pct.

p2p_unbilled_receiptsReceived, not yet billedA
Read-onlyIdempotent
Inspect

Goods received and not yet on an approved bill, line by line, with their value: what is owed for and not yet billed (GRNI).

Inputs: no named parameters.

pros_discard_pullDiscard a pullA
Destructive
Inspect

Throw out one staged pull and every unpromoted row from it, with a reason, so it can be re-read and staged again. A wrong pull means a wrong file: staged rows are never edited, the pull is discarded and handed over again from a fresh read. Rows that already became accounts are NOT removed and are listed back — an account is a real thing now and deleting the row behind it would leave the account with no provenance. The hash is free again afterwards. Effects: pull and its unpromoted rows deleted; promoted rows kept and listed; hash free to stage again.

Inputs: reason (required), source_id (required).

pros_import_rowsImport a pullAInspect

Hand over one pulled list: what it was bought or scraped under, and its rows. These are not accounts and never become accounts here. You read the file; this records it. Nothing here parses and nothing here qualifies.

CRITERIA IS MANDATORY AND IT IS THE POINT (PRO-2). Write the brief this pull was actually made under: the size band, the geography, the industries asked for. A pull whose criteria nobody wrote down cannot have its verdicts checked against anything afterwards, and rows judged against a brief that was never stated are judged against your memory of it.

The same hash is refused twice (PRO-1). Rows whose company name is already staged, or already an account, are skipped and listed back — say so to the person. The batch is accepted whole or refused: if the file says a row count and you hand over a different number, re-read it.

Hand over the seller's own description verbatim rather than your summary of it. Your reading of the row belongs in a verdict, where it is attributed to you and can be argued with. Effects: pull recorded with its criteria; rows staged with provenance; duplicates skipped and listed.

Inputs: hash (required), rows (required), label (required), criteria (required), +2 more.

pros_promotePromote to accountsA
Destructive
Inspect

Turn qualified staged rows into real accounts under a campaign. A person's act, always. HUMAN-ONLY: this act is refused to you whatever your role — the curated list is the asset, and an agent that could fill it from a bought list would empty the curation of meaning. Ask your human to do it. This is the door between a bought list and a curated one, and it opens from one side only. An agent may stage rows and judge them; a person decides which become accounts.

Only rows with a 'qualified' verdict promote. Each becomes an account carrying the verdict's reason as its why_them and the row's own source as its source_url, so the account arrives with the provenance CRM-3 demands rather than an invented justification. Read the verdicts first: promoting is agreeing with them.

A row promotes once. What it became is recorded on the row, so the pull keeps saying what came of it long after the rows stop mattering. Effects: crm accounts created from qualified rows; rows marked promoted with the account they became.

Inputs: row_ids (required), campaign_id (required), tier.

pros_qualifyQualify staged rowsA
Destructive
Inspect

Record a judgement on staged rows. Never creates an account. One row or a whole pull in a single call. READ THE PULL'S CRITERIA FIRST (pros_sources). A verdict is a judgement against a stated brief, not against your general sense of a good customer.

THE REASON IS THE PRODUCT (PRO-3). It is read by a person deciding whether to overrule you, and by somebody months later asking why this company was dropped. "Hospitality, no desk-based back office to measure" is useful. "Not a fit" is not, and is refused. Cite a source_url when the answer came from the company's own site rather than the row.

AN INDUSTRY LABEL IS NOT EVIDENCE. The seller's label covers two different businesses more often than not; read the description and the site before deciding.

USE "unclear" RATHER THAN GUESSING. If the row does not say what you need, that is a real finding and leaves the row for a person. A confident wrong rejection is invisible: nobody ever audits the companies that were dropped.

A bad row does not discard the rest — each is applied on its own and the response reports what failed. Qualifying is not promoting: you cannot create an account from a bought list, and that is deliberate (PRO-5). Effects: verdicts recorded against staged rows, per row.

Inputs: verdicts (required).

pros_rowsStaged rowsA
Read-onlyIdempotent
Inspect

One page of staged rows, with an honest count of everything the filter matched. judged=false IS THE "WHAT IS LEFT TO JUDGE" QUERY and it is usually the one you want. It is not the same as any verdict filter: an unjudged row has no verdict at all.

BRIEF IS THE DEFAULT AND YOU ALMOST ALWAYS WANT IT. The seller's description is a marketing paragraph; fifty of them at full length exceed the tool output cap and the call fails outright rather than truncating. Brief cuts each to 200 characters, which decides most rows. Ask for brief=false on the handful where the cut description genuinely is not enough, and lower the limit when you do.

ALWAYS READ total_matching AND has_more. The page caps at 200 and the sort is total, so paging with offset never skips or repeats a row — but a page is not the answer to "how many".

Inputs: brief, limit, judged, offset, +4 more.

pros_sourcesPullsA
Read-onlyIdempotent
Inspect

Every staged pull with the brief it was made under and how far it has been judged. Read the criteria before judging any of its rows: a verdict is a judgement against a stated brief, not against your general sense of a good customer.

Inputs: source_id.

purch_accept_suggestionsAccept suggestionsA
Destructive
Inspect

Confirm what standing rules suggest, in one reasoned act: every waiting row, or one rule's rows, minus any the person says are not part of it. This is a review act, so it follows the person's confirmation, never the rule alone. Show them the rows first (purch_rules lists each rule with the rows it is suggesting for), and leave out any row they say does not belong with except. The reason is their confirmation. Effects: status and category recorded on every row accepted.

Inputs: reason (required), except, rule_id.

purch_accountsAccountsA
Read-onlyIdempotent
Inspect

Every account with its balance (from its latest statement, a stated value, or its loan), as of when, and any gap or jump between its statements. With account_id: that one account whole, its statements in order and the values stated for it.

Inputs: as_of, account_id.

purch_add_accountAdd accountAInspect

Add an account to the register: a bank or savings account, a credit card, a loan, or something with a value (a house, a car). Name it as its statements print it ("Chase Checking ending 4410"), so statements find it. Importing a statement for an account that is not here yet adds it by itself; add one by hand for a card or loan before its first statement, or for something that never has statements (a house, a car): give that its value with purch_record_value, from a source the person names. Effects: account added to the register.

Inputs: kind (required), name (required), currency (required), last4, +3 more.

purch_add_billAdd a billAInspect

Record a bill a vendor sent: who, their number, the dates, the amount. It waits for a person to approve paying it; nothing is paid from here. You were handed a vendor's invoice (a PDF, a photo, an email). Record what it says: the vendor's name, their invoice number, the bill date, the due date (or the days they give), the amount and currency as printed, and the category in the person's words. Never invent a number or a date; empty beats guessed. The same vendor and number is refused a second time, so a bill forwarded twice is caught. Then tell the person it is waiting for their approval: only a person approves paying a bill (purch_approve_bill), and the payment itself happens in their bank. purch_payables shows what is coming due against the cash on their latest statement. Effects: bill recorded, waiting for approval.

Inputs: amount (required), vendor (required), bill_date (required), number, +8 more.

purch_add_receiptAdd receiptAInspect

Record a receipt you read: vendor, date, total, and the file's name and hash. Candidates to match come back; matching is a separate act. The file stays with the person (P-9); this keeps what it says. HAND OVER THE LINES TOO when the receipt prints them, tax as its own line: they must add up to the total, and that check is what catches a misread digit in a photo, the same way a statement's printed balances catch a misread row. If the lines do not add up, the receipt is refused and you look again; never adjust a number to make it fit. Then look at the candidates and match with purch_match_receipt, with a reason. An unmatched receipt is a visible state, not an error. Effects: receipt recorded, unmatched.

Inputs: date (required), hash (required), name (required), total (required), +6 more.

purch_add_ruleAdd standing ruleAInspect

Remember something ahead of time ("the next five days are the Texas conference, book it to travel"): matching rows get a suggested category until someone reviews them. When the person tells you about spending before it shows up on a statement (a trip, an event, a project, "everything from this shop is office supplies"), record it as a standing rule. Turn relative dates into real ones from today ("the next five days" from 2026-10-05 is 2026-10-05 to 2026-10-09) and say them back. A rule needs a window, words the statement line will contain, or a vendor; the category is the person's word. A rule SUGGESTS: it never books a row. Rows it matches show the suggestion and stay unreviewed until the person confirms them, in review or with purch_accept_suggestions. Effects: rule recorded; matching unreviewed rows carry its suggestion.

Inputs: label (required), category (required), to, from, +5 more.

purch_approve_billApprove paymentA
Destructive
Inspect

A person approves paying a bill, optionally by a date. Approval is not payment: the money moves in their bank. HUMAN-ONLY: this act is refused to you whatever your role — Approving a payment is a person's decision about their own money. Ask your human to do it. Refused to you whatever your role. Show the person the bill and what is due around it (purch_payables), and let them approve it in the app. Effects: bill approved for payment.

Inputs: bill_id (required), note, pay_by.

purch_billsBillsA
Read-onlyIdempotent
Inspect

Bills on record: open ones waiting for approval first, then approved, paid and rejected.

Inputs: status.

purch_bill_seriesExpected billsA
Read-onlyIdempotent
Inspect

Each bill that comes every period: its usual amount from its own history, when the next is expected, whether one is missing or unusually high, and autopay. With series_id: that one with its bills.

Inputs: as_of, series_id.

purch_card_costsInterest and feesB
Read-onlyIdempotent
Inspect

Interest and fees per card for a year, from the rows reviewed as fees.

Inputs: year.

purch_card_duesCard payments dueB
Read-onlyIdempotent
Inspect

Each card: its latest statement balance, minimum and due date, the payments seen toward it, and whether it is paid in full, minimum paid, due, or missed.

Inputs: as_of.

purch_close_accountClose accountA
Destructive
Inspect

Mark an account closed from a day, with a reason. It stays in the register and its statements stay; it leaves net worth from that day. Only when the person says it is closed. A closing balance that is not zero is named in the result, not refused: that money went somewhere worth recording. Effects: account closed from a day.

Inputs: reason (required), closed_on (required), account_id (required).

purch_declare_bill_seriesExpect a billAInspect

Say a vendor's bill comes every period (the electric bill, the phone, insurance), so a missing one, or one well above the usual amount, is named. When the person says a bill comes regularly, declare it once: the vendor as they say it, how often, the category, and the usual amount if they know it. Its bills are then the vendor's bills on record; the usual amount comes from them once there are a few. Never guess a usual amount. Effects: bill expected every period from this vendor.

Inputs: vendor (required), cadence (required), reason, due_day, +3 more.

purch_declare_subscriptionDeclare subscriptionAInspect

Declare a recurring charge from one you have seen. The record then confirms it period by period. Declared, then confirmed (P-6): every period from the start date is matched against the vendor's charges within a tolerance; a period with none shows as missed, two in a row make it lapsed. Never declare one the person has not confirmed exists. Effects: subscription declared active.

Inputs: amount (required), vendor (required), cadence (required), currency (required), +3 more.

purch_discard_sourceDiscard statementA
Destructive
Inspect

Throw out one imported statement and every row that came from it, with a reason, so it can be re-read and imported again. A wrong row means a wrong source (P-2): rows are never edited, the statement is discarded and imported again from a fresh read. Receipts matched to its rows go back to unmatched and are listed; vendors, aliases and subscriptions stay — they are the person's words, not the statement's. The hash is free again afterwards. Owner's act, on the record. Effects: source and its transactions deleted; matched receipts unmatched; hash free to import again.

Inputs: reason (required), source_id (required).

purch_end_bill_seriesStop expectingA
Destructive
Inspect

Stop expecting a vendor's bill (moved, cancelled, switched provider), with a reason. Its bills stay on record. Only when the person says the bill has stopped. Autopay ends with it. Effects: bill no longer expected; autopay ended.

Inputs: reason (required), series_id (required).

purch_end_ruleEnd ruleA
Destructive
Inspect

Stop a standing rule. Its suggestions go away; rows already reviewed keep what the person confirmed. End a rule when the person says it no longer holds, or when it was recorded wrong (then add the right one). Ending never changes a reviewed row. Effects: rule ended; its suggestions removed from unreviewed rows.

Inputs: reason (required), rule_id (required).

purch_end_subscriptionEnd subscriptionA
Destructive
Inspect

Record that a subscription ended because the person cancelled it with the vendor, with a reason. Periods after that are no longer expected. Saybooks cancels nothing with the vendor; it only stops expecting the charge. Cancelled is a fact the person states, not something the module infers: a subscription that stops charging shows as lapsed on its own, and stays that way until the person says it was cancelled. Record when, if they know, in the reason. Effects: subscription cancelled.

Inputs: reason (required), subscription_id (required).

purch_get_billBillB
Read-onlyIdempotent
Inspect

One bill with its approval and payment.

Inputs: bill_id (required).

purch_get_receiptReceiptC
Read-onlyIdempotent
Inspect

One receipt and, if unmatched, its candidate rows.

Inputs: receipt_id (required).

purch_get_ruleStanding ruleC
Read-onlyIdempotent
Inspect

One rule with the unreviewed rows it is suggesting for.

Inputs: rule_id (required).

purch_get_subscriptionSubscriptionB
Read-onlyIdempotent
Inspect

One subscription with every period matched or missed.

Inputs: subscription_id (required), as_of.

purch_get_transactionTransactionC
Read-onlyIdempotent
Inspect

One row: provenance, review, vendor, receipt.

Inputs: transaction_id (required).

purch_import_statementImport statementAInspect

Hand over one statement: the balances it prints and its lines as you were given them. Accepted whole, or refused with the gap named. You were handed a file; this reads it. Pass the statement's lines in text exactly as you have them, one row per line, and state the opening and closing balance the statement PRINTS. That is the normal way, and the only way when you have the text: retyping rows is where digits slip. The rows are read here; the batch is refused unless opening + rows = closing, and the refusal names the gap (P-3). Never adjust a line to make it fit: re-read.

rows as typed fields exists for one case only: a statement you have no text for, a person reading from paper. row_count is the count the statement prints, if it prints one; leave it out otherwise. hash is computed from the text; pass one only with rows. The same statement is refused a second time (P-4); rows already on record are skipped and listed back. Nothing is categorised here; review follows. Effects: source recorded; transactions recorded with provenance; duplicates skipped and listed.

Inputs: kind (required), name (required), currency (required), period_end (required), +13 more.

purch_match_receiptMatch receiptA
Destructive
Inspect

Tie a receipt to one transaction, with a reason. Refused when the total does not fit. One receipt, one transaction (P-7). Refused when the receipt total is not the row's amount or the dates are more than seven days apart — unless you pass override with a reason that says why (a split payment, a tip added at the till). Effects: receipt matched to transaction.

Inputs: reason (required), receipt_id (required), transaction_id (required), override.

purch_net_worthNet worthB
Read-onlyIdempotent
Inspect

What is held less what is owed, per currency, on a day: each account's figure with its date and source; old figures named.

Inputs: as_of.

purch_pair_transferPair a transferA
Destructive
Inspect

Tie the two sides of one move between your own accounts: the row where money left and the row where it arrived. Counted once, as neither spending nor income. Paying the card from checking shows twice: out of checking, into the card. Read purch_transfers for the suggested pairs (same amount, close in time, worded as a payment), show the person, and pair with a reason. The amounts must be exactly opposite and the accounts different; a pair is refused otherwise. A transfer to an account that has no statements here (a savings account kept elsewhere, an owner draw) is not a pair: review that row as a transfer naming where the money went. Effects: both rows reviewed as one transfer; the move counted once, between the two accounts.

Inputs: reason (required), in_transaction_id (required), out_transaction_id (required).

purch_payablesWhat is coming dueB
Read-onlyIdempotent
Inspect

Bills waiting to be paid by when they are due (overdue, next 7 days, next 30, later), set against the cash on the latest bank statements.

Inputs: as_of.

purch_purchasesPurchasesC
Read-onlyIdempotent
Inspect

Reviewed spending: by category, by month, by vendor, per currency.

Inputs: to, from, vendor, category.

purch_receiptsReceiptsC
Read-onlyIdempotent
Inspect

Receipts on record, matched or not.

Inputs: unmatched.

purch_record_bill_paymentRecord the paymentA
Destructive
Inspect

Record that a bill was paid, after the fact: the day it went, how, and the statement row that shows it when there is one. Only after the person paid it, and only with the day it actually went. An agent records payments for approved bills only; a person recording one approves it in the same act. Link the statement row (transaction_id) when the payment is on an imported statement: the amount and currency must match and it must be money out. An unreviewed row is reviewed as the bill says (purchase, its category and vendor), because the bill is the person's word for what it was. Effects: bill marked paid; statement row linked and reviewed when given.

Inputs: bill_id (required), paid_at (required), method, reference, +1 more.

purch_record_reimbursementRecord paid backA
Destructive
Inspect

Tie money in to the work expenses it paid back. They must add up to it exactly; together they are no longer personal spending. Work expenses are marked when reviewed (reimbursable_by, claim_ref). When the employer or client pays them back, read purch_reimbursements, find the expenses the money covers (often one claim), show the person, and tie them with a reason. The expenses must add up to the money in exactly; if less came back than was claimed, tie the ones it covers and leave the rest waiting. Effects: money in tied to the expenses it paid back; those expenses no longer personal spending.

Inputs: reason (required), expenses (required), in_transaction_id (required).

purch_record_valueRecord a valueAInspect

State what something without statements is worth, or what is still owed on it, on a day, with where the figure comes from: a house, a car, an outside loan. A value is the person's figure with where it comes from (according_to: "county assessment 2026", "Kelley Blue Book, private party", "lender's payoff letter"). Never estimate one yourself. Bank and card balances come from their statements, not from here. Give the amount as a positive number: what it is worth for a thing you own, what is owed for a loan; the sign follows the kind. Effects: value recorded with its date and source.

Inputs: as_of (required), amount (required), account_id (required), according_to (required), +1 more.

purch_refundsRefundsC
Read-onlyIdempotent
Inspect

Money back linked to the purchase it reverses, and money in that looks like money back from the same shop (suggested, with why). With refund_id: that link whole.

Inputs: refund_id.

purch_reimbursementsPaid backC
Read-onlyIdempotent
Inspect

Work expenses waiting to be paid back (with how long; a long wait named), and the money that paid them back.

Inputs: as_of.

purch_reject_billReject the billA
Destructive
Inspect

Record that a bill will not be paid as it stands: wrong, disputed, a duplicate, not theirs. With a reason. Rejecting is a decision about a vendor relationship: do it when the person says so, with their reason. The bill stays on the record. Effects: bill rejected.

Inputs: reason (required), bill_id (required).

purch_rename_categoryRename categoryA
Destructive
Inspect

Change a category word on every row that carries it, in one act. Categories are the person's words; when the word changes, every row follows in one reasoned act rather than a re-review. Renaming onto an existing word merges the two. Effects: category replaced on every row that carried it.

Inputs: to (required), from (required), reason.

purch_review_batchReview manyA
Destructive
Inspect

Review a whole statement in one act: status, category and vendor per row, one reason. Checked whole; refused whole. READ purch_vocabulary FIRST: it holds the statuses and what they mean, and the person's own categories and vendors, which are the words to use. Propose a status, a category and a vendor for every row, show the person the whole table, and write nothing until they have answered. Then write it all in one act with their confirmation as the reason.

Every row marked recurring must carry its vendor (the shop's name, e.g. "Adobe"): naming it is what declares the subscription. A transfer's category is where the money went or came from (checking, savings, the card being paid). Every row is validated before any is written, and the batch is refused whole with the row and the fix named; a row you cannot name stays out of the batch and unreviewed, never guessed. Up to 200 rows. Effects: status, category, vendor recorded on every row listed.

Inputs: rows (required), reason.

purch_review_transactionReviewA
Destructive
Inspect

Say what a row is — purchase, recurring, transfer, income, fee, ignored — with a category, a vendor and a reason. Amount and date never change. A reasoned act (P-5). Read purch_vocabulary first and propose from the person's own categories and vendors. purchase is one-off spending; recurring is spending that repeats (rent, streaming, insurance) — name the vendor and the subscription is declared for you, then confirmed month by month (P-6). A transfer is money moving between the person's own accounts (card payoffs, brokerage, savings, an owner draw): give it a category saying WHERE it went, so the ledger's bank balance still ties to the statement. Leave that blank only when the money is already recorded elsewhere in these books, such as a client payment against an invoice you issued; those rows are then listed as not posted rather than counted twice. A fee is the bank's charge; income is money in; ignored is a row that is not theirs to track. Never alter the amount or the date — a wrong row means a wrong source, re-read and re-imported. Effects: status, category, vendor, note recorded; subscription declared for a recurring row with a vendor.

Inputs: status (required), transaction_id (required), note, reason, +5 more.

purch_rulesStanding rulesC
Read-onlyIdempotent
Inspect

Rules the person set ahead of time, each with its window, what it suggests, and how many unreviewed rows it is suggesting for right now.

Inputs: include_ended.

purch_set_autopayRecord autopayA
Destructive
Inspect

Record that the person set a vendor's bills to be paid automatically from one account (at their bank or with the vendor), or stopped it. Saybooks pays nothing: from then on that vendor's bills count as approved by this standing decision, and say so. HUMAN-ONLY: this act is refused to you whatever your role — Letting a vendor take its bills from an account on its own is the person's standing decision to pay them. Ask your human to do it. A person sets autopay in the app, whatever an agent's role: it approves paying every bill of that vendor ahead. An agent records the bills, and the payments when the statement shows them. Effects: vendor's bills approved ahead from one account, or no longer.

Inputs: reason (required), series_id (required), off, account_id.

purch_set_card_factsCard statement factsA
Destructive
Inspect

Record what a card statement prints besides its rows: the minimum payment, the payment due date, the credit limit and the purchase rate. Kept as printed; changing them later needs a reason. Pass them with the import when you have the statement (purch_import_statement takes the same fields). Use this for a statement imported without them, or to correct a misread, with a reason. Copy the figures as printed; never work a minimum out from the balance. Effects: card statement facts recorded.

Inputs: source_id (required), apr_bp, reason, minimum_due, +2 more.

purch_set_vendorName the vendorA
Destructive
Inspect

Name the shop behind a row once; its statement spelling becomes an alias for every later row. One vendor, many spellings. The alias is the description as printed; pass it (or let it default to the row's description) so the next statement names the shop by itself. Effects: vendor created if new; alias recorded; vendor set on every unassigned row with that description.

Inputs: vendor (required), transaction_id (required), alias, reason.

purch_sourceStatement (personal finances)C
Read-onlyIdempotent
Inspect

One statement with its rows and reconciliation.

Inputs: source_id (required).

purch_sourcesStatementsA
Read-onlyIdempotent
Inspect

Every statement imported: period, account, balances, rows in and skipped, who imported it.

Inputs: no named parameters.

purch_spendSpendB
Read-onlyIdempotent
Inspect

Spending by month, category and vendor, per currency — the numbers behind the charts.

Inputs: to, from.

purch_split_transactionSplit a rowA
Destructive
Inspect

Say how one statement row breaks down: several categories that add up to it exactly. The row itself never changes. One line on a statement is often several things: a payroll run is wages, employer taxes and the processor's fee; a warehouse trip is supplies and groceries. The statement only knows the total, so the breakdown comes from the person or from a document they have — the payroll report, the receipt. Never invent the split; ask, or leave the row whole.

The legs must add to the row's amount exactly. They are refused otherwise, with the gap named, for the same reason a statement is: a breakdown that does not add up is a transcription error. The row keeps its amount, its date and the line it came from; only the ledger sees the legs, each posting to its own category against the account the money moved on. Pass remove to drop a split and put the row back to its single category. Effects: split legs recorded, replacing any earlier split.

Inputs: transaction_id (required), parts, reason, remove.

purch_subscriptionsSubscriptionsB
Read-onlyIdempotent
Inspect

Every declared subscription with its periods matched or missed, derived status, next expected charge, and the monthly equivalent per currency.

Inputs: as_of.

purch_tag_categoryTax tagA
Destructive
Inspect

Tag a category for tax time (medical, charitable, business, home office, education, childcare), or clear its tag. The year summary totals tagged spending and lists rows without a receipt. The tag is the person's word on what their category is, never yours on what is deductible: ask, then tag. Clear it with tag none. Saybooks totals; it does not advise. Effects: category tagged, or its tag cleared.

Inputs: tag (required), category (required), reason.

purch_transactionsTransactionsA
Read-onlyIdempotent
Inspect

Rows on record, newest first, with filters. unreviewed says how many still need a word.

Inputs: to, from, limit, status, +3 more.

purch_transfersTransfersB
Read-onlyIdempotent
Inspect

Moves between your own accounts: the pairs, the rows that look like the two sides of one move (suggested, with why), and transfers with one side so far. With transfer_id: that pair whole.

Inputs: transfer_id.

purch_unmatch_receiptUnmatch receiptA
Destructive
Inspect

Detach a receipt from its transaction, with a reason. A match was a reasoned act; undoing it is one too. The receipt goes back to unmatched, a visible state, and the reason stays on the record. Use it when the person says the receipt belongs to a different row or card — then match again. Effects: receipt unmatched.

Inputs: reason (required), receipt_id (required).

purch_unpair_transferUnpairA
Destructive
Inspect

Undo a pairing, with a reason. Both rows go back to how they were reviewed before. For a pair that was wrong. Say so to the person: both rows need reviewing again. Effects: pair undone; both rows back to their earlier review.

Inputs: reason (required), transfer_id (required).

purch_upcomingWhat is dueA
Read-onlyIdempotent
Inspect

Everything on record due in the next weeks (bills, card payments, loan payments, subscriptions, expected bills not received yet) by date, beside the cash on the latest bank statements. Nothing unrecorded is assumed.

Inputs: days, as_of.

purch_update_accountUpdate account (personal finances)A
Destructive
Inspect

Change what the register says about an account: its kind, institution, last four digits, opening date, notes. Its name stays: statements are filed under it. Corrections from what the person or a statement says. A kind that does not fit the statements already on it is refused. Effects: account details updated.

Inputs: account_id (required), kind, last4, notes, +2 more.

purch_vocabularyWords in useA
Read-onlyIdempotent
Inspect

Statuses with their meaning, the person's categories and vendors with aliases, cadences, subscriptions — read this before proposing a review.

Inputs: no named parameters.

purch_yearThe yearC
Read-onlyIdempotent
Inspect

A year as the record has it: spending by tax tag net of refunds and of what was paid back, rows in a tagged category with no receipt, interest paid on cards and loans and interest earned, fees, and expenses still waiting to be paid back. Totals, not tax advice.

Inputs: year.

rec_accountsBank accountsB
Read-onlyIdempotent
Inspect

Each bank and card account with its latest statement, where its reconciliation stands, and the last day signed off.

Inputs: no named parameters.

rec_candidatesMatch suggestionsA
Read-onlyIdempotent
Inspect

Statement rows that could be money already recorded here, each with the payments that fit it and why. Suggestions only.

Inputs: account.

rec_get_matchMatchC
Read-onlyIdempotent
Inspect

One match: the row, the payments, the reason.

Inputs: match_id (required).

rec_matchMatch to a paymentA
Destructive
Inspect

Tie a statement row to the payments or refunds recorded here that it is. They must add up to the row exactly. The row then posts nothing itself: the payment already did. A deposit on the statement is often a payment already recorded against an invoice. Read rec_candidates: per row, what fits by amount, date and name. Show the person, then match with a reason ("the Northwind ACH is their payment NW-ACH-2210"). One row can be several payments (a deposit of three checks); the items must add up to the row exactly, never "close enough". A row already booked as income or spending cannot be matched: that would count the money twice; say what it is booked as and let the person decide. Never record a payment just to have something to match. Effects: statement row matched; it posts nothing itself; the payments it is are now on the statement.

Inputs: items (required), reason (required), transaction_id (required).

rec_matchesMatchesB
Read-onlyIdempotent
Inspect

Every match between a statement row and payments recorded here, newest first, undone ones included.

Inputs: no named parameters.

rec_reconciliationReconciliationB
Read-onlyIdempotent
Inspect

An account through a statement's last day: the statement's balance, the books' balance, and every item between them, named. Says what blocks a sign-off.

Inputs: account (required), through, currency.

rec_sign_offSign off the reconciliationAInspect

Sign off an account's reconciliation through a statement's last day, with a reason. It is kept as it stands: the figures, the items and a hash. HUMAN-ONLY: this act is refused to you whatever your role — A reconciliation is a person's word that the bank and the books were looked at and agree. Ask your human to do it. A person signs this, in the app, once the reconciliation is explained to the cent. An agent prepares it (matches, reviews) and shows rec_reconciliation; it is refused the sign-off whatever its role. Effects: reconciliation signed off and kept as it stood.

Inputs: reason (required), account (required), through (required).

rec_signoffsSign-offsA
Read-onlyIdempotent
Inspect

Every signed reconciliation: account, through, figures, by whom, and whether the record has changed since.

Inputs: no named parameters.

rec_unmatchUnmatchA
Destructive
Inspect

Undo a match, with a reason. The row goes back to how it was reviewed before; the payments are unmatched again. For a match that was wrong. The row returns to its earlier review (often not reviewed); say so to the person. Effects: match undone; the row back to its earlier review.

Inputs: reason (required), match_id (required).

solo_apply_paymentApply to invoice (invoicing)A
Destructive
Inspect

Settle an invoice (or part of it) with a recorded payment. Bounded on both sides — never more than the payment has left, never more than the invoice still owes; refusals name the numbers. Effects: application recorded; invoice -> paid when fully settled.

Inputs: invoice_id (required), payment_id (required), amount.

solo_draft_invoiceDraft invoiceAInspect

Start an invoice as an editable draft. Nothing is final until you issue it. Gather the lines as the person describes the work — description, quantity or hours, rate — and SHOW them the numbers before issuing. Timing is their agreement with the client: ahead of the work, partial, or after — never question it (S-5). Never invent an amount or a rate (S-6). If there is no client yet, ask for the client's name, billing address, email, and the agreed terms — one question at a time — and create the customer first. The draft comes back with doc_url: a preview link that renders the real document marked DRAFT. Call solo_get_document to see that render yourself and hand the person the link BEFORE asking whether to issue; never hand-roll the document yourself. Effects: draft created with computed totals; preview link minted.

Inputs: lines (required), customer_id (required), notes, subject, +2 more.

solo_draft_reminderDraft a reminderAInspect

Write a payment reminder for an overdue invoice. It is a draft the person sends from their own mailbox; Saybooks never sends it. For an invoice past its due date with money still open (solo_outstanding lists days_overdue, reminders_sent and next_stage). Write it in the person's voice, short and specific: the invoice number, the amount open, the due date, and pdf_url from solo_get_document so the client can pay without hunting. A first reminder assumes it slipped; a second asks when to expect payment; a final one says plainly what happens next, but only what the person has told you. Never mention a late fee, interest or a collections step that was not agreed: the figures are checked, and an amount the invoice does not have is refused. Show the person the draft. They send it themselves; when they say it went, record it with solo_reminder_outcome and the date it went. Effects: reminder drafted against the invoice.

Inputs: body (required), subject (required), invoice_id (required), soon_because.

solo_get_documentDocumentA
Read-onlyIdempotent
Inspect

The rendered document: a picture of one page to look at, and — once issued — the direct download link for the PDF. Use this to SEE the invoice before asking whether to issue: a draft comes back as an image stamped DRAFT, so you check the real render, not the JSON. After issue, call it again and hand the person pdf_url — a direct, unauthenticated, one-click download of the finished PDF; they send it themselves (S-7). Do not fetch or relay the bytes yourself: the link IS the deliverable. with_pdf=true exists only as a fallback for a client that cannot open links at all. Pages count from 1.

Inputs: invoice_id (required), page, with_pdf.

solo_get_invoiceInvoice (invoicing)B
Read-onlyIdempotent
Inspect

The whole document: lines, totals, frozen seller block, what is applied and open, and the shareable doc link.

Inputs: invoice_id (required).

solo_get_reminderReminderC
Read-onlyIdempotent
Inspect

One reminder with its invoice's open amount now.

Inputs: reminder_id (required).

solo_issue_invoiceIssueA
Destructive
Inspect

Make it real: freeze the seller and bill-to blocks, set the due date; the preview link becomes the document. Issuing is the point of no return (S-2): the seller block freezes from your company profile and the bill-to block from the customer (S-3), the due date is computed from the draft's terms, and the preview link becomes the document. Show the person the preview (doc_path) and the full numbers and get their confirmation BEFORE calling this. Refused without a company profile or a customer billing address — the refusal says what to gather. After: call solo_get_document and hand the person pdf_url — a direct download of the finished PDF; they send it themselves (S-7). Do not relay the bytes. Effects: invoice issued and immutable; seller and bill-to blocks frozen; document link final; PDF available.

Inputs: invoice_id (required).

solo_outstandingOutstandingA
Read-onlyIdempotent
Inspect

Who owes what: issued, unpaid invoices oldest first, with days overdue and the total open. This is the morning read. Chasing is the freelancer’s act — the system never sends anything.

Inputs: no named parameters.

solo_record_paymentRecord payment (invoicing)AInspect

Money arrived. Recording it and deciding what it settles are two acts. Never guess which invoice a payment is for — unapplied is a valid, visible state. Ask, or leave it unapplied. Effects: payment recorded as unapplied.

Inputs: amount (required), customer_id (required), method, currency, +2 more.

solo_reminder_outcomeWhat happened to a reminderA
Destructive
Inspect

Record that the person sent a reminder, and when, or that they discarded it, and why. SENT: the person sent it from their own mailbox and is telling you so. sent_at is the day it actually went, not today by default. Never record a send nobody told you about: a reminder that did not go is the one fact here that can embarrass a person in front of a client. DISCARDED: they decided against it; the reason is for whoever drafts the next one. Effects: reminder closed as sent or discarded.

Inputs: outcome (required), reminder_id (required), reason, sent_at.

solo_remindersRemindersA
Read-onlyIdempotent
Inspect

Payment reminders: drafts waiting to be sent first, then what went and when, with a mailto link that opens each draft addressed and filled in.

Inputs: status.

solo_statementStatement (invoicing)A
Read-onlyIdempotent
Inspect

One client, chronological: every invoice and payment with a running balance.

Inputs: customer_id (required).

solo_update_draftUpdate draftA
Destructive
Inspect

Change a draft: lines, due days, notes. Drafts are the only editable state. Once issued, an invoice is immutable (S-2) — corrections after that are void-and-reissue, on the record. Effects: draft updated, totals recomputed.

Inputs: invoice_id (required), lines, notes, subject, +2 more.

solo_void_invoiceVoidA
Destructive
Inspect

Kill an invoice, on the record. The number stays burned (S-4). Void is for mistakes and cancellations; the reason is part of the record. The document stays readable and printable, stamped VOID, at the same link — a record you cannot read is not a record. Nothing on it is collectible: open drops to 0. An invoice with payments applied cannot be voided at 0.1 — unwinding applied cash needs its own design (see the spec's deferred list). Reissue corrected work as a fresh draft. Effects: invoice void; number burned; open = 0; document stays readable, stamped VOID.

Inputs: reason (required), invoice_id (required).

tax_filingsFilingsA
Read-onlyIdempotent
Inspect

Every filed return: the period, what was filed and paid, and whether the record has changed since.

Inputs: no named parameters.

tax_get_filingFilingB
Read-onlyIdempotent
Inspect

One filed return with its kept figures and payments.

Inputs: filing_id (required).

tax_liabilitySales tax owedA
Read-onlyIdempotent
Inspect

Sales tax owed as of a day, beside Sales Tax Payable in the books, and each month: due, filed, paid, or not filed.

Inputs: as_of.

tax_record_filingRecord a filed returnAInspect

Record that a sales tax return was filed for a period: what was filed, when, with whom, and the confirmation. The return is kept as it stood. HUMAN-ONLY: this act is refused to you whatever your role — Filing a sales tax return is the person's signature to the tax agency. Ask your human to do it. The person files on the agency's site, then records it here: the period, the amount filed, the day and the confirmation. An agent prepares the return (tax_return) and shows it, and is refused this record whatever its role. An amount that differs from the return needs a reason; a later change to a filed period shows as changed since. Effects: return recorded as filed, kept as it stood with a hash.

Inputs: period (required), reason (required), filed_on (required), filed_amount (required), +3 more.

tax_record_paymentRecord the tax paymentAInspect

Record that a filed return was paid: the day, the amount and the reference. It clears the liability, and the bank reconciliation waits for the statement row that shows it. Record a payment after it happened, against the filing it pays, with the day it went and the agency's reference. Never more than the filing still owes. Nothing here pays anything. The payment then waits in the bank reconciliation like any recorded payment until the statement shows it. Effects: payment recorded against the filing; the liability goes down by it.

Inputs: amount (required), paid_on (required), filing_id (required), method, +2 more.

tax_returnSales tax returnC
Read-onlyIdempotent
Inspect

The return for a period: taxable and non-taxable sales, the tax charged by rate, the tax given back on credits, what is due, and changes to periods already filed.

Inputs: to, from, period, currency.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Enables an AI assistant to read Portuguese invoices and receipts, file them by tax year, and book them into an Excel or Google Sheets workbook. It works out the boxes of the quarterly IVA return, tracks IRS and Segurança Social totals, and reports what documents are still missing.
      16
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables Dutch sole proprietors with few invoices to keep their books through an existing AI assistant, handling invoices, receipts, btw returns, KOR tracking, and year reports using deterministic Dutch tax rules.
      24
      AGPL 3.0
    • A
      license
      A
      quality
      B
      maintenance
      Enables an AI assistant to track bills, renewals, subscriptions, warranties, birthdays and appointments kept as plain local files, import bank statements to see spending by category, plan monthly savings for big yearly bills, and export reminders to the user's own calendar with UK bank holidays built in. Everything stays on the user's computer, with card numbers refused and figures drawn only from their own records.
      20
      438 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables an AI client to query and do bookkeeping across all of a user's Xero organisations, Zoho Books organisations and FreeAgent companies through one connector, from invoices, bills, bank transactions and reports to creating and updating records. Read-only and write tools plus ready-made prompts cover cash balances, month-end checks and who owes whom, all across companies at once.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.