Saybooks
Server Details
Books your AI keeps from your own bank statements: cards, loans, bills, receipts and the tax year.
- 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
Scored across 236 tools
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.
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.
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.
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
- Documentation
- https://saybooks.io/docs#connect
- Privacy policy
- Not provided
- Trust center
- Not applicable
- Restrictions
- No setup restrictions
Available Tools
236 toolsbridge_accountsAccount mapARead-onlyIdempotentInspect
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-oversARead-onlyIdempotentInspect
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 financialsARead-onlyIdempotentInspect
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 accountADestructiveInspect
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-overARead-onlyIdempotentInspect
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 trailARead-onlyIdempotentInspect
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 profileARead-onlyIdempotentInspect
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_customerCustomerARead-onlyIdempotentInspect
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 holdADestructiveInspect
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 memberADestructiveInspect
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_journalJournalARead-onlyIdempotentInspect
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_membersMembersARead-onlyIdempotentInspect
Who has access: email members (Google sign-in) and token keys (agents, link shares).
Inputs: no named parameters.
core_next_actionsWhat can I do nowARead-onlyIdempotentInspect
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 stockADestructiveInspect
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 holdADestructiveInspect
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 scenarioADestructiveInspect
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 workspaceADestructiveInspect
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 memberADestructiveInspect
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_schemaSchemaARead-onlyIdempotentInspect
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_searchSearchBRead-onlyIdempotentInspect
Find entities by id, name or reference, across every module. Each module contributes its own results; what you can find here tracks what is mounted.
Inputs: q (required).
core_set_company_logoCompany logoADestructiveInspect
Put your logo on the invoice document. Upload a file, or give a public https URL and it is fetched once. Branding, not a fact: the logo is NOT part of the frozen seller block, so changing it re-brands past documents while their names, addresses and amounts stay exactly as issued. PNG, JPEG, SVG or WebP, 300 KB at most; the image is stored, never hotlinked. Needs a company profile first. Pass remove=true to take it off. Effects: company logo stored (or removed).
Inputs: remove, logo_url, logo_data.
core_set_company_profileSet company profileADestructiveInspect
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 limitADestructiveInspect
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 priceADestructiveInspect
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 checklistARead-onlyIdempotentInspect
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 statusARead-onlyIdempotentInspect
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 customerADestructiveInspect
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_workspacesWorkspacesARead-onlyIdempotentInspect
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_eventAttendanceADestructiveInspect
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_calendarCalendarARead-onlyIdempotentInspect
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_campaignsCampaignsARead-onlyIdempotentInspect
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_coverageCoverageBRead-onlyIdempotentInspect
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 draftADestructiveInspect
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_draftsDraftsARead-onlyIdempotentInspect
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_gapsGapsBRead-onlyIdempotentInspect
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_accountAccountBRead-onlyIdempotentInspect
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_campaignCampaignBRead-onlyIdempotentInspect
One campaign: goal, status, and health.
Inputs: campaign_id (required).
crm_get_contactContact (CRM)CRead-onlyIdempotentInspect
One person: identity, provenance, gap state, the activity that touched them.
Inputs: contact_id (required).
crm_list_contactsContacts (CRM)BRead-onlyIdempotentInspect
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)ARead-onlyIdempotentInspect
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 customerADestructiveInspect
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 gapADestructiveInspect
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 statusADestructiveInspect
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 statusADestructiveInspect
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 inADestructiveInspect
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_todayTodayARead-onlyIdempotentInspect
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)ADestructiveInspect
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 campaignADestructiveInspect
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)ADestructiveInspect
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 draftADestructiveInspect
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 eventADestructiveInspect
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 closeBRead-onlyIdempotentInspect
What the record now says differently about closed periods, per account, landing on the first open day.
Inputs: no named parameters.
gl_checklistClose checklistARead-onlyIdempotentInspect
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 booksADestructiveInspect
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_closesClosesBRead-onlyIdempotentInspect
Every close: through when, by whom, its totals and hash, and whether the record has changed since.
Inputs: no named parameters.
gl_entriesAdjusting entriesARead-onlyIdempotentInspect
Adjusting entries, newest first, with their lines and any reversal.
Inputs: no named parameters.
gl_entryAdjusting entryCRead-onlyIdempotentInspect
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 closeADestructiveInspect
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 entryADestructiveInspect
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 interviewADestructiveInspect
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_applyApplyADestructiveInspect
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 duplicatesARead-onlyIdempotentInspect
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 actionBDestructiveInspect
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)CRead-onlyIdempotentInspect
People with relationship, source, and last touch.
Inputs: relationship.
hunt_correct_applicationCorrect recordADestructiveInspect
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_dueDueARead-onlyIdempotentInspect
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_postingEvaluateADestructiveInspect
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)CRead-onlyIdempotentInspect
One person whole: identity, provenance, relationship, the postings they touch, full touch history.
Inputs: contact_id (required).
hunt_get_postingPostingARead-onlyIdempotentInspect
One posting whole: facts, evaluation, application, interviews, touch history, open next action.
Inputs: posting_id (required).
hunt_get_resumeResume versionARead-onlyIdempotentInspect
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 outcomeADestructiveInspect
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 touchADestructiveInspect
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)ARead-onlyIdempotentInspect
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 versionsBRead-onlyIdempotentInspect
The registry, with how many applications each version went out on.
Inputs: no named parameters.
hunt_set_application_statusMove applicationADestructiveInspect
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)ADestructiveInspect
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 postingADestructiveInspect
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 salesARead-onlyIdempotentInspect
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 countADestructiveInspect
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 stockARead-onlyIdempotentInspect
One item's stock moves, newest first, with the quantity, average cost and value after each.
Inputs: item_id (required).
inv_movesStock movesBRead-onlyIdempotentInspect
Every change to stock, newest first: received, shipped, returned, counted, adjusted, opening.
Inputs: limit, item_id.
inv_set_opening_costSet opening costADestructiveInspect
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_stockStockBRead-onlyIdempotentInspect
Every stocked item: on hand, average cost and value, and any stock without a cost.
Inputs: no named parameters.
inv_valuationStock valuationARead-onlyIdempotentInspect
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 suggestionsBRead-onlyIdempotentInspect
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_getLoanBRead-onlyIdempotentInspect
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 paidARead-onlyIdempotentInspect
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_link_paymentLink a paymentADestructiveInspect
Tie the statement row that paid the loan to it, split into principal, interest and escrow: as the lender printed it, or by the schedule when no split is given. Read loan_candidates for rows that look like the payment. When the lender's statement prints the split (principal, interest, escrow), pass it: it is the record, and it must add up to the row. With no split given, the schedule works it out from the balance and the rate, and the result says so. Anything above the scheduled payment and escrow goes to principal. Effects: payment split and recorded; the row posts once, through the loan.
Inputs: reason (required), loan_id (required), transaction_id (required), escrow, +2 more.
loan_loansLoansARead-onlyIdempotentInspect
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.
loan_unlink_paymentUnlink a paymentADestructiveInspect
Undo a payment link, with a reason. The row goes back to how it was reviewed; the balance moves back. For a link that was wrong, or to relink it with the lender's split once the statement arrives. Say so to the person. Effects: payment unlinked; the row back to its earlier review.
Inputs: reason (required), loan_id (required), payment_id (required).
o2c_accept_quoteCustomer acceptedADestructiveInspect
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 orderADestructiveInspect
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 invoiceADestructiveInspect
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)ADestructiveInspect
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 agingARead-onlyIdempotentInspect
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_backordersBackordersARead-onlyIdempotentInspect
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)ADestructiveInspect
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 shortADestructiveInspect
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 orderADestructiveInspect
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 statementARead-onlyIdempotentInspect
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)CRead-onlyIdempotentInspect
Customer with live credit position: limit, open AR, committed value, available.
Inputs: customer_id (required).
o2c_get_invoiceInvoice (order to cash)CRead-onlyIdempotentInspect
Invoice with lines and what is still open on it.
Inputs: invoice_id (required).
o2c_get_orderOrderCRead-onlyIdempotentInspect
Full order: lines, open and uninvoiced quantities, deliveries, invoices, and what can be done to it now.
Inputs: order_id (required).
o2c_invoice_shippedInvoice shippedADestructiveInspect
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 returnADestructiveInspect
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_refundRefundADestructiveInspect
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 quoteADestructiveInspect
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_orderShipADestructiveInspect
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 cashCRead-onlyIdempotentInspect
Payments received that no invoice claims yet.
Inputs: no named parameters.
o2c_void_invoiceVoid invoiceADestructiveInspect
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 offADestructiveInspect
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 matchBRead-onlyIdempotentInspect
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)ADestructiveInspect
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 shortADestructiveInspect
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 receivedARead-onlyIdempotentInspect
What arrived, against which order, when, at the order's prices. Newest first.
Inputs: po_id.
p2p_issue_poIssue orderADestructiveInspect
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 orderARead-onlyIdempotentInspect
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 ordersCRead-onlyIdempotentInspect
Orders by state, with what is still to arrive on each.
Inputs: state.
p2p_receive_goodsReceive goodsADestructiveInspect
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 toleranceADestructiveInspect
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 billedARead-onlyIdempotentInspect
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 pullADestructiveInspect
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 accountsADestructiveInspect
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 rowsADestructiveInspect
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 rowsARead-onlyIdempotentInspect
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_sourcesPullsARead-onlyIdempotentInspect
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 suggestionsADestructiveInspect
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_accountsAccountsARead-onlyIdempotentInspect
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 paymentADestructiveInspect
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_billsBillsARead-onlyIdempotentInspect
Bills on record: open ones waiting for approval first, then approved, paid and rejected.
Inputs: status.
purch_bill_seriesExpected billsARead-onlyIdempotentInspect
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 feesBRead-onlyIdempotentInspect
Interest and fees per card for a year, from the rows reviewed as fees.
Inputs: year.
purch_card_duesCard payments dueBRead-onlyIdempotentInspect
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 accountADestructiveInspect
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 statementADestructiveInspect
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 expectingADestructiveInspect
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 ruleADestructiveInspect
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 subscriptionADestructiveInspect
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_billBillBRead-onlyIdempotentInspect
One bill with its approval and payment.
Inputs: bill_id (required).
purch_get_receiptReceiptCRead-onlyIdempotentInspect
One receipt and, if unmatched, its candidate rows.
Inputs: receipt_id (required).
purch_get_ruleStanding ruleCRead-onlyIdempotentInspect
One rule with the unreviewed rows it is suggesting for.
Inputs: rule_id (required).
purch_get_subscriptionSubscriptionBRead-onlyIdempotentInspect
One subscription with every period matched or missed.
Inputs: subscription_id (required), as_of.
purch_get_transactionTransactionCRead-onlyIdempotentInspect
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_link_refundLink a refundADestructiveInspect
Tie money back to the purchase it reverses. It takes back that much of the purchase's spending, in its category; it is not income. Read purch_refunds: money in that looks like money back from the same shop. Show the person and link with a reason. A refund is never more than what is left of the purchase after earlier refunds. Money back for something not on record stays income. Effects: refund row tied to its purchase; the purchase's spending reduced by it.
Inputs: reason (required), refund_transaction_id (required), purchase_transaction_id (required).
purch_match_receiptMatch receiptADestructiveInspect
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 worthBRead-onlyIdempotentInspect
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 transferADestructiveInspect
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 dueBRead-onlyIdempotentInspect
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_purchasesPurchasesCRead-onlyIdempotentInspect
Reviewed spending: by category, by month, by vendor, per currency.
Inputs: to, from, vendor, category.
purch_receiptsReceiptsCRead-onlyIdempotentInspect
Receipts on record, matched or not.
Inputs: unmatched.
purch_record_bill_paymentRecord the paymentADestructiveInspect
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 backADestructiveInspect
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_refundsRefundsCRead-onlyIdempotentInspect
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 backCRead-onlyIdempotentInspect
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 billADestructiveInspect
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 categoryADestructiveInspect
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 manyADestructiveInspect
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_transactionReviewADestructiveInspect
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 rulesCRead-onlyIdempotentInspect
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 autopayADestructiveInspect
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 factsADestructiveInspect
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 vendorADestructiveInspect
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)CRead-onlyIdempotentInspect
One statement with its rows and reconciliation.
Inputs: source_id (required).
purch_sourcesStatementsARead-onlyIdempotentInspect
Every statement imported: period, account, balances, rows in and skipped, who imported it.
Inputs: no named parameters.
purch_spendSpendBRead-onlyIdempotentInspect
Spending by month, category and vendor, per currency — the numbers behind the charts.
Inputs: to, from.
purch_split_transactionSplit a rowADestructiveInspect
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_subscriptionsSubscriptionsBRead-onlyIdempotentInspect
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 tagADestructiveInspect
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_transactionsTransactionsARead-onlyIdempotentInspect
Rows on record, newest first, with filters. unreviewed says how many still need a word.
Inputs: to, from, limit, status, +3 more.
purch_transfersTransfersBRead-onlyIdempotentInspect
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_unlink_refundUnlink refundADestructiveInspect
Undo a refund link, with a reason. The money-in row goes back to how it was reviewed before. For a link that was wrong: the money in goes back to how it was reviewed, and the purchase counts in full again. Say so to the person. Effects: refund unlinked; the row back to its earlier review.
Inputs: reason (required), refund_id (required).
purch_unlink_reimbursementUntieADestructiveInspect
Undo a reimbursement tie, with a reason. The money in goes back to how it was reviewed; the expenses wait again. For a tie that was wrong: say so to the person, since the expenses count as theirs again until tied correctly. Effects: tie undone; the money in back to its earlier review.
Inputs: reason (required), reimbursement_id (required).
purch_unmatch_receiptUnmatch receiptADestructiveInspect
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_transferUnpairADestructiveInspect
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 dueARead-onlyIdempotentInspect
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)ADestructiveInspect
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 useARead-onlyIdempotentInspect
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 yearCRead-onlyIdempotentInspect
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 accountsBRead-onlyIdempotentInspect
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 suggestionsARead-onlyIdempotentInspect
Statement rows that could be money already recorded here, each with the payments that fit it and why. Suggestions only.
Inputs: account.
rec_get_matchMatchCRead-onlyIdempotentInspect
One match: the row, the payments, the reason.
Inputs: match_id (required).
rec_matchMatch to a paymentADestructiveInspect
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_matchesMatchesBRead-onlyIdempotentInspect
Every match between a statement row and payments recorded here, newest first, undone ones included.
Inputs: no named parameters.
rec_reconciliationReconciliationBRead-onlyIdempotentInspect
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-offsARead-onlyIdempotentInspect
Every signed reconciliation: account, through, figures, by whom, and whether the record has changed since.
Inputs: no named parameters.
rec_unmatchUnmatchADestructiveInspect
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)ADestructiveInspect
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_documentDocumentARead-onlyIdempotentInspect
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)BRead-onlyIdempotentInspect
The whole document: lines, totals, frozen seller block, what is applied and open, and the shareable doc link.
Inputs: invoice_id (required).
solo_get_reminderReminderCRead-onlyIdempotentInspect
One reminder with its invoice's open amount now.
Inputs: reminder_id (required).
solo_issue_invoiceIssueADestructiveInspect
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_outstandingOutstandingARead-onlyIdempotentInspect
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 reminderADestructiveInspect
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_remindersRemindersARead-onlyIdempotentInspect
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)ARead-onlyIdempotentInspect
One client, chronological: every invoice and payment with a running balance.
Inputs: customer_id (required).
solo_update_draftUpdate draftADestructiveInspect
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_invoiceVoidADestructiveInspect
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_filingsFilingsARead-onlyIdempotentInspect
Every filed return: the period, what was filed and paid, and whether the record has changed since.
Inputs: no named parameters.
tax_get_filingFilingBRead-onlyIdempotentInspect
One filed return with its kept figures and payments.
Inputs: filing_id (required).
tax_liabilitySales tax owedARead-onlyIdempotentInspect
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 returnCRead-onlyIdempotentInspect
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
Your longbook of bills, subscriptions and expenses, for your AI to read and to suggest changes to.
Receipts per month, matched to your bank statement. Your AI finds the missing ones, attaches them.
Double entry accounting run by your own AI: books, VAT figures, invoices, month close (UK, DE, AT).
Your books in your AI assistant: draft expenses, bills, invoices, estimates; ask about P&L, tax.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables 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.16MIT
- AlicenseAqualityBmaintenanceEnables 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.24AGPL 3.0
- AlicenseAqualityBmaintenanceEnables 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.20438 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables 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
Glama MCP Gateway
Add one secure layer between your agents and this server.