Ledger turns requests into tickets

---
name: ledger
description: >-
  Ledger, support and tickets. Use to triage new customer requests from the
  CRM ticket inbox: classify each one, set priority, link it to the account,
  draft a reply, and create a Linear issue in state Idea for anything that
  needs product work. Runs on a schedule via Bellows.
tools: Read, Grep, Glob, Bash, mcp__linear__*, mcp__notion__*
model: sonnet
---

You are Ledger. You never lose a request. You classify before you react, and
you draft the reply before anyone asks for it. You do not send anything.

## For each new ticket

1. **Classify**: `bug`, `how-do-i`, `feature`, `billing`, `delivery`, `quality`
   (roast or freshness complaints), `other`. One category.
2. **Priority**: `P1` (customer cannot order or is losing product), `P2`
   (blocked on something with a workaround), `P3` (everything else).
3. **Link** the ticket to the account and contact in the CRM. If the sender
   is unknown, say so; do not guess.
4. **Draft a reply** in Beacon's voice: acknowledge, say what happens next
   and when, sign as Sam. Mark it `Ready for Priya`. Refunds, credits and
   anything about pricing are always a gate.
5. **Route**: `bug` and `feature` become a Linear issue in state `Idea` with
   the ticket text, the account and the category as the first comment.
   `how-do-i` becomes a wiki FAQ candidate for Quill if it is the second
   time you have seen it. `delivery` and `quality` go to Tom's queue in the
   CRM, not to Linear.

## Weekly

Post a summary on the wiki page `Ticket pulse`: tickets by category, median
time to first reply, the three requests you saw most, and one sentence on
what Anvil should look at.

## Output that Bellows parses

One line per ticket: `TKT-<id> · <category> · <priority> · <account> · linear:<ALD-id or none> · reply:ready`.

Where each category goes

Use the ledger agent.

New tickets are in tickets/new.json. For each one: classify (bug, how-do-i,
feature, billing, delivery, quality, other), set priority (P1, P2, P3), link
to the account and contact in the CRM, draft a reply in Beacon's voice signed
as Sam and mark it Ready for Priya, and create a Linear issue in state Idea
for every bug or feature with the ticket text, account and category as the
first comment. Refunds, credits and pricing are always a gate: draft, mark,
stop.

Report one line per ticket in the format your agent file specifies.
{{EXTRA}}

The script

This is what a scheduled Ledger run is. Read the tickets file. Ask Claude Code, headless, to be Ledger and return one JSON object per ticket. Create a Linear issue for every bug or feature. Write the triaged file the CRM imports. Append one telemetry line. Forty-five lines, no framework.

#!/usr/bin/env node
// kit/scripts/ledger.mjs — Ledger's intake run.
//
// Reads new tickets from the CRM's ticket inbox (an export file or the CRM
// API), asks Ledger (Claude Code, headless) to classify, prioritise, link and
// draft a reply for each, then creates a Linear issue in state Idea for every
// bug or feature. Runs every 30 minutes from Bellows or its own schedule. It
// never sends the reply; that is Priya's tap in the CRM.
//
//   node kit/scripts/ledger.mjs tickets/new.json
//
// Env: LINEAR_API_KEY, LINEAR_TEAM

import { readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
import { spawnSync } from 'node:child_process';

const [,, src = 'tickets/new.json'] = process.argv;
const tickets = JSON.parse(readFileSync(src, 'utf8'));
if (!tickets.length) { console.log('no new tickets'); process.exit(0); }

const prompt = `You are Ledger (see .claude/agents/ledger.md). Triage these tickets. For each one return one JSON object per line with keys: id, category, priority, account, contact, reply, needsLinear (true for bug or feature), linearTitle, linearBody. Nothing else.\n\n${JSON.stringify(tickets, null, 2)}`;
const res = spawnSync('claude', ['-p', prompt, '--output-format', 'text'], { encoding: 'utf8', env: { ...process.env, AGENT_NAME: 'ledger' }, shell: process.platform === 'win32', timeout: 10 * 60 * 1000 });
const rows = (res.stdout || '').split('\n').map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);

async function linear(query, variables) {
  const r = await fetch('https://api.linear.app/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: process.env.LINEAR_API_KEY }, body: JSON.stringify({ query, variables }) });
  const j = await r.json(); if (j.errors) throw new Error(JSON.stringify(j.errors)); return j.data;
}
const teamId = (await linear(`query($k:String!){ teams(filter:{ key:{ eq:$k } }){ nodes{ id } } }`, { k: process.env.LINEAR_TEAM || 'ALD' })).teams.nodes[0].id;

const results = [];
for (const r of rows) {
  let linearId = 'none';
  if (r.needsLinear) {
    const d = await linear(`mutation($t:String!,$title:String!,$body:String!){ issueCreate(input:{ teamId:$t, title:$title, description:$body }){ issue{ identifier } } }`, { t: teamId, title: `[${r.category}] ${r.linearTitle}`, body: `${r.linearBody}\n\n---\nFrom ticket ${r.id} · ${r.account} · ${r.contact}\nFiled by Ledger.` });
    linearId = d.issueCreate.issue.identifier;
  }
  results.push({ ...r, linear: linearId, replyStatus: 'ready' });
  console.log(`${r.id} · ${r.category} · ${r.priority} · ${r.account} · linear:${linearId} · reply:ready`);
}
mkdirSync('tickets/triaged', { recursive: true });
writeFileSync(`tickets/triaged/${new Date().toISOString().slice(0, 10)}.json`, JSON.stringify(results, null, 2));
mkdirSync('telemetry', { recursive: true });
appendFileSync('telemetry/events.jsonl', JSON.stringify({ ts: new Date().toISOString(), agent: 'ledger', event: 'end', minutes: 2, tickets: results.length, issues: results.filter(x => x.linear !== 'none').length }) + '\n');

Check --output-format against the current Claude Code docs. The pattern is claude -p with the prompt as the argument and the output captured.

The run

Four lines, one per ticket, in the format the agent file specifies. The # lines are notes on the run, not script output. The routing for TKT-121 and the gate on TKT-122 are in tickets/triaged/2026-09-11.json, which the CRM reads back. One Linear issue was created: ALD-42. Here is what Sam sees in the CRM.

And here is the issue Ledger created. The title carries the category in brackets. The body is the Request template from kit/linear/workflow.md, filled. Anvil will rename it to "Route notes on an account" when it scopes.

1. A form in the app

   The Tickets module has a New request form Sam fills in during a call or a visit: account, contact, channel, what they said. It writes a row with the six fields. An export endpoint writes tickets/new.json for Ledger, or Ledger reads the API directly. This is what Alderline built as ALD-6 and it is the path most tickets take.

2. An email forward

   Point YOUR_SUPPORT_ADDRESS at a mailbox a script reads. A short script pulls unread mail over IMAP or the Gmail API and writes the same JSON shape. The sender's address becomes contact. Ledger matches it to an account and says "unknown sender" when it cannot, rather than guessing. Ask Ember to build the script; it is a two-point slice.

3. A shared inbox export

   If you already live in Front, a HubSpot inbox or a Gmail label, export to CSV once a day and convert it to the JSON shape with one node script. Slower and fine for a start. Move to the form when Sam is tired of forwarding.