Exported functions in state/lib/sales.ts. .md file to compare - side-by-side diff against sales
sales
description: "Triggers on prompt mention of 'sales', 'lead', 'leads', 'pipeline', or 'prospect' - `lead`/`leads` were missing from the trigger set so freeform queries like 'show me my leads' fell through."
What it does for you
Keeps your sales pipeline moving and up to date.
What it produces
A recent result, so you can see the kind of work it returns.
loading…
How to get it
These run inside the Snappy workspace. Want this working in your business? I set skills like this up with you, in one focused week.
For developers how this skill is built, graded, and how it runs
at a glance- the short version
what's inside - the parts that make up a skill 3/4 present
A skill is just a few plain-text files. Only the main one is required. The rest are optional, added as the work needs them. This is what the skill is made of; how it runs is just below.
state/skills/sales/SKILL.md
present
state/lib/sales.ts
present
state/bin/sales/
not present
state/skills/sales/AGENTS.md
present
how it's graded - what counts as a good run 4 criteria · 3 deterministic · 1 judge
Each row is one thing a good run has to get right. deterministic means a quick check decides, pass or fail. judge means the AI reads the result and rates it. Grading each piece on its own (instead of one overall score) shows exactly where a run fell short, so the fix is obvious.
how it runs - the shared frame every skill uses 4/5 present
Every skill runs the same way. One part does the work, a separate part checks it, and a short loader hands the AI exactly what it needs for the job. Anything this skill doesn't use shows a one-line note saying why, on purpose, not by accident.
This skill doesn't fix its own gaps yet.
state/log/pending-eval.ndjson - NEVER frame sales drafts with scarcity hooks ("idle hours", "leftover budget"). Banned per memory: no scarcity offers; Robert is system owner, value-first only.
- ALWAYS log activity via logActivity() after touching a lead/client - the pipeline cares about the audit trail, not just the outcome.
what it has learned - fixes written back in over time sample
When a run hits something this skill didn't handle, the fix gets written back into the skill so it doesn't happen again. FIXED means it was corrected on the spot. LOGGED means it's queued for a bigger rewrite. Either way, the skill gets a little better and never makes the same mistake twice.
- Loading feedback rows…
how the work flows- who makes it, who checks it
SKILL.md- the skill, written out in plain English
sales
Sales pipeline operations via snappy-knowledge.
Ported from kernel snappy-sales in Phase 0.5. See state/lib/sales.ts for the full API surface.
Steps
getLeads()- seestate/lib/sales.tsgetSalesClients()- seestate/lib/sales.tslogActivity()- seestate/lib/sales.ts
Eval
Actor: the exported functions in state/lib/sales.ts. Auditor: none wired yet - eval is manual (Robert review). File a state/log/pending-eval.ndjson row on each run.
Score convention:
| Outcome | Score |
|---|---|
| Pass on first try | 1.0 |
| Failed first, auto-fix applied, re-check passed | 0.5 |
| Still failing or unrecoverable | 0.0 |
Gotchas
via the Phase 0.5 driver. Only these rewrites were applied: already in state/lib/)
realpathSync(process.argv[1])CLI guard wrapped in try/catch
- See the kernel SKILL.md for the original long-form guidance if you need it
(read-only reference at the kernel path above).
Graduation
This skill is prose. Graduate by defining a deterministic auditor and flipping eval: auto.
Rubric
criteria:
- name: get_leads_returns_nonzero
kind: deterministic
check: "getLeads() executes and returns array with length > 0 (at least one lead item, not empty array or null)."
- name: get_sales_clients_returns_nonzero
kind: deterministic
check: "getSalesClients() executes and returns array with length > 0 (at least one client, not empty array or null)."
- name: log_activity_writes_record
kind: deterministic
check: "logActivity(input) executes, returns {success: true, record_id, ...}, and the record is persisted (verifiable via a subsequent read)."
- name: data_shapes_match_spec
kind: judge
check: "Leads array contains {id, name, status, ...}; clients array contains {id, name, ...}; activity record has {id, timestamp, activity_type, ...}."AGENTS.md- what the AI loads when this skill comes up
sales - loader
Per-turn rules for the sales skill. Full reference: state/skills/sales/SKILL.md.
Compound Response Pattern (MANDATORY)
When this loader fires, you MUST compose a structured pipeline card - NOT flat prose.
Steps (always follow this order):
- Query Xano for leads/deals if available:
import { getLeads, getSalesClients } from "../lib/sales.ts" Fallback: pull recent client meetings from Krisp: sqlite3 ~/.local/share/krisp-pp-cli/data.db "SELECT name, date FROM meetings ORDER BY date DESC LIMIT 10"
- Compose via
compose_inline:
root = Card([
CardHeader("Sales Pipeline"),
Stack([
Callout("Active Opportunities", [...leads/deals from Xano or Krisp meeting context as ListBlock items, or "No active opportunities found"...]),
Callout("This Week's Calls", [...meetings with client names from Krisp as ListBlock items, or "No calls this week"...]),
Callout("Next Actions", [...2-3 suggested follow-ups based on what you see...]),
]),
FollowUpBlock([
SnappyFollowUpItem("draft a follow-up email", "Draft follow-up"),
SnappyFollowUpItem("what's the status with Ray", "Ray status"),
SnappyFollowUpItem("generate a sales summary for this week", "Weekly sales summary"),
])
])
- Always include the FollowUpBlock - even if pipeline data is empty.
Critical Rules
_(no failures recorded yet - this skill has not produced hard-won rules. It is a Phase 0.5 port from kernel snappy-sales. Read state/lib/sales.ts for the actual API surface before invoking.)_
- NEVER frame sales drafts with scarcity hooks ("idle hours", "leftover budget"). Banned per memory: no scarcity offers; Robert is system owner, value-first only.
- ALWAYS log activity via
logActivity()after touching a lead/client - the pipeline cares about the audit trail, not just the outcome.
Commands
| ui model | live composition via compose_inline, persisted as artifact lang_body, reopened with OpenArtifact | |invoke (TS): import { getLeads, getSalesClients, logActivity } from "../lib/sales.ts" |eval log: state/log/pending-eval.ndjson (skill: "sales") - manual until auditor wired
Known Pitfalls
- Phase 0.5 port stub. Real behavior in
state/lib/sales.ts. - This skill reads the pipeline; it does not send outbound. Any outreach must go through an explicit mutation-gated channel flow.
Self-Test
An agent reading this should correctly:
- [ ] Refuse to draft a sales touch with scarcity framing
- [ ] Log activity after every lead/client mutation
- [ ] Distinguish sales (read pipeline) from outbound (send messages)
Found a gap? Edit this file. <!-- footer-injection-point -->
api.ts- the code it can call
#!/usr/bin/env npx tsx
/**
* snappy-sales/api.ts -- Sales pipeline operations via snappy-knowledge.
*
* Usage:
* npx tsx api.ts leads # all contacts tagged "lead"
* npx tsx api.ts leads hot # leads also tagged "hot"
* npx tsx api.ts clients # all contacts tagged "client"
* npx tsx api.ts log 123 "Discovery call -- strong fit, follows up Day 2"
*
* Or import as module:
* import { getLeads, getSalesClients, logActivity } from "./sales.ts";
*/
import { listContacts, updateContact } from "./knowledge.ts";
import { env } from "./env.ts";
import { realpathSync } from "fs";
/** Get leads, optionally filtered by a sub-status tag (e.g. "hot", "warm"). */
export async function getLeads(status?: string) {
const all = await listContacts("lead");
if (!status || !Array.isArray(all)) return all;
return all.filter((c: any) =>
Array.isArray(c.tags) && c.tags.some((t: string) => t === status || t === `temp:${status}`)
);
}
/** Get all contacts tagged "client". */
export async function getSalesClients() {
return listContacts("client");
}
/** Append a dated note to a contact and update last_contact. */
export async function logActivity(contactId: number, note: string) {
const today = new Date().toISOString().slice(0, 10);
// Read-modify-write: fetch current contact, append note
const contacts = await listContacts();
const contact = Array.isArray(contacts)
? contacts.find((c: any) => c.id === contactId)
: null;
const existing = contact?.notes || "";
const updated = existing + `\n\n[${today}] ${note}`;
return updateContact(contactId, { notes: updated, last_contact: today });
}
// --- CLI ---
if ((() => { try { return import.meta.url === `file://${realpathSync(process.argv[1])}`; } catch { return false; } })()) {
(async () => {
const [, , cmd, ...args] = process.argv;
switch (cmd) {
case "leads": {
const data = await getLeads(args[0] || undefined);
console.log(JSON.stringify(data, null, 2));
break;
}
case "clients": {
const data = await getSalesClients();
console.log(JSON.stringify(data, null, 2));
break;
}
case "log": {
const [id, ...noteParts] = args;
if (!id || !noteParts.length) {
console.error("Usage: api.ts log <contact_id> <note>");
process.exit(1);
}
const data = await logActivity(parseInt(id, 10), noteParts.join(" "));
console.log(JSON.stringify(data, null, 2));
break;
}
default:
console.log("Usage: npx tsx api.ts [leads|clients|log] ...");
}
})();
}
scripts- helper scripts it can run
prose-only skill - 1 inline code block live in SKILL.md above (no state/bin/ sidecar yet).
how we check it- the checks, plus the last 10 runs
no recent runs logged - the eval contract is declared but nothing has been graded yet