OR Key
drop another .md file to compare - side-by-side diff against sales

sales

Keeps your sales pipeline moving and up to date.
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."
personal 2 files

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.

Work with me
For developers how this skill is built, graded, and how it runs

at a glance- the short version

actorExported functions in state/lib/sales.ts.
auditorNone wired yet - eval is manual (Robert review).
eval modeshape
categoryKnowledge
stages1

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.

The skill
state/skills/sales/SKILL.md present
the skill itself, in plain text
The main file. It says what the skill is and lays out the steps in plain English.
Code
state/lib/sales.ts present
code the skill can run
Reusable code this skill can call when it needs to.
Scripts
state/bin/sales/ not present
helper scripts
Optional. Added when a skill has a few commands to run.
Loader
state/skills/sales/AGENTS.md present
what the AI loads on the fly
Loaded automatically the moment this skill is needed. Kept short on purpose.

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.

name
kind
check
get_leads_returns_nonzero
deterministic
getLeads() executes and returns array with length > 0 (at least one lead item, not empty array or null).
get_sales_clients_returns_nonzero
deterministic
getSalesClients() executes and returns array with length > 0 (at least one client, not empty array or null).
log_activity_writes_record
deterministic
logActivity(input) executes, returns {success: true, record_id, ...}, and the record is persisted (verifiable via a subsequent read).
data_shapes_match_spec
judge
Leads array contains {id, name, status, ...}; clients array contains {id, name, ...}; activity record has {id, timestamp, activity_type, ...}.

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.

makes the work The worker
present
Exported functions in state/lib/sales.ts. the worker
Does the actual work. Whatever it produces is what gets checked next.
checks the work The reviewer
present
None wired yet - eval is manual (Robert review). the checker
A separate checker grades the work, so the part that made it can't approve its own work.
frame
learns Self-correction
not present

This skill doesn't fix its own gaps yet.

tidies up Background fixes
present
queued for rewrite runs in the background
Bigger fixes that can't be made on the spot get queued and rewritten in the background later.
remembers Run history
present
state/log/pending-eval.ndjson pending runs
Every run is written down here, then reviewed by hand each week.
Critical rules the things this skill must not get wrong
  1. NEVER frame sales drafts with scarcity hooks ("idle hours", "leftover budget"). Banned per memory: no scarcity offers; Robert is system owner, value-first only.
  2. 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.

  1. Loading feedback rows…

how the work flows- who makes it, who checks it

actor Exported functions in state/lib/sales.ts.
auditor None wired yet - eval is manual (Robert review).
1 data
eval log
`state/log/pending-eval.ndjson` (skill: "sales") - manual until auditor wired

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() - see state/lib/sales.ts
  • getSalesClients() - see state/lib/sales.ts
  • logActivity() - see state/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:

OutcomeScore
Pass on first try1.0
Failed first, auto-fix applied, re-check passed0.5
Still failing or unrecoverable0.0

Gotchas

via the Phase 0.5 driver. Only these rewrites were applied: already in state/lib/)

  1. 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):

  1. 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"

  1. 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"),
  ])
])
  1. 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:

  1. [ ] Refuse to draft a sales touch with scarcity framing
  2. [ ] Log activity after every lead/client mutation
  3. [ ] 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

rubric shape schema-shape check (no inline rubric)
recent no runs actor/auditor: unverifiable
deps none declared

no recent runs logged - the eval contract is declared but nothing has been graded yet