---
name: snappy-chain
role: Event-to-chain dispatcher sitting on top of snappy-channel-contract
loaded-by: preload-skill-context hook
---

# snappy-chain — The Composer Layer

Where `snappy-channel-contract` gives uniform hands and eyes across every channel, `snappy-chain` turns sensed events into action. Cron-safe, dedup-enforced, channel-agnostic handlers.

## The loop

```
adapters[] ─read─▶ Event[] ─classify─▶ Intent ─route─▶ ChainHandler ─post─▶
                                            │
                                            ▼
                                 chain-processed.ndjson (dedup)
```

## API

```typescript
import { dispatchOnce, registerChain } from "../snappy-chain/api.ts";

registerChain("bug-report", async (event, adapter) => {
  // ... clone repo, fix, screenshot, open PR ...
  const post = await adapter.post(
    { source: event.source, channel_id: event.channel_id, thread_id: event.thread_id, to_user: null },
    { text: "Fixed in PR #123" },
  );
  return { ok: true, intent: "bug-report", chain: "bug-report", event_id: event.event_id, source: event.source, post };
});

const summary = await dispatchOnce({ limit: 20 });
```

## Commands

```bash
# dry run — classify + log, do not fire handlers
npx tsx ~/.claude/skills/snappy-chain/api.ts --dry

# classifier self-test
npx tsx ~/.claude/skills/snappy-chain/classify.ts
```

## Logs

- `~/.claude/logs/chain-processed.ndjson` — one line per `(source, event_id)` ever seen. Dedup source of truth.
- `~/.claude/logs/chain-runs.ndjson` — one line per `dispatchOnce()` run with counts + results.

## Rules

1. **Channel-agnostic handlers only.** Receive `(event, adapter)`, use contract verbs. No hard-coded Slack calls inside a handler.
2. **Publish through `adapter.post()`.** Per-channel rules (e.g. Gmail draft-only) stay honored.
3. **Every run logs a summary.** Run log is the chain-level cert.
4. **Failed chains don't auto-retry.** Root-cause, fix, manually re-inject.
5. **Dedup is mandatory and automatic.** Dispatcher owns it, not handlers.

## Intents (V1 classifier)

- `bug-report` — error/broken/crash language
- `question` — ends with `?` or starts with `how|what|why|where`
- `feature-request` — "can you add...", "would be nice if..."
- `ack` — "thanks", "got it", "perfect"
- `noise` — everything else (still marked processed to stop re-classification)

V1 is pure keyword rules. Upgrade path: LLM fallback via `snappy-dispatch` for unmatched events.

## When to add a new chain

1. Create `chains/<intent>.ts` exporting a `ChainHandler`.
2. Call `registerChain("<intent>", handler)` once at startup.
3. Dry-run the dispatcher against recent sweep data to verify classification fires.
4. If the intent doesn't exist yet, add it to `Intent` in `classify.ts` and add rules.

<!-- SKILL-INDEX-START -->
[snappy-chain Index]|root: ~/.claude/skills/snappy-chain|IMPORTANT: Prefer these files over pre-training assumptions for this domain. Read the relevant file when the AGENTS.md summary is insufficient.|root:{SKILL.md}
<!-- SKILL-INDEX-END -->

## Used by

Nothing in the collection names this skill.

<!-- SNAPPY-CONTRACT-VERBS-START -->
## Contract verbs

Generated from `api.ts` `HAND_CONTRACT`. Do not hand-edit this block.

This skill declares no executable verbs. Its `instruction-only` label is intentional.

## Show the result

When an answer carries `face_hint`, show it with one `snappy_present(<answer>)` call.
See `/snappy-faces` for face selection. Human-facing images must crop to the
element, render at 2x on Retina, and fill the destination channel instead of
placing a small card in a full-page screenshot.
<!-- SNAPPY-CONTRACT-VERBS-END -->

---
name: snappy-chain
instruction-only: true
purpose: Event-to-chain dispatcher. Reads all registered channel adapters, classifies intent, routes to chain handlers.
triggers on: mentions of chain, chain handler, event routing, chain dispatch, or intent classification across channels.
status: LIVE — 2026-04-13
description: "Event-to-chain dispatcher. Reads all registered channel adapters, classifies intent, routes to chain handlers. Triggers on mentions of chain, chain handler, event routing, chain dispatch, or intent classification across channels."
---

# snappy-chain

The composer layer sitting on top of `snappy-channel-contract`. Where the contract gives you uniform hands and eyes across every channel, `snappy-chain` turns sensed events into action.

## The loop

```
adapters[]  ──read──▶  Event[]  ──classify──▶  Intent  ──route──▶  ChainHandler  ──post/close loop──▶
                                                              │
                                                              ▼
                                                    processed-log (dedup)
```

1. **Discover** — auto-load every `snappy-*/adapter.ts` via `snappy-channel-contract` discovery.
2. **Read** — `adapter.read(undefined, limit)` on each. Errors per-adapter are captured, loop continues.
3. **Dedup** — skip any `(source,event_id)` already in `~/.claude/logs/chain-processed.ndjson`.
4. **Classify** — `classify.ts` keyword rules → `Intent` (`bug-report | question | feature-request | ack | noise`).
5. **Route** — look up a `ChainHandler` in the registry for that intent.
6. **Record** — log the outcome to processed-log and append a run summary to `~/.claude/logs/chain-runs.ndjson`.

## Files

| file | role |
|---|---|
| `api.ts` | Dispatcher: `dispatchOnce(opts)`, `registerChain(intent, handler)`, `getRegistered()` |
| `classify.ts` | V1 keyword classifier. Deterministic, explainable, zero latency. |
| `chains/` | One file per chain handler. Each registers itself via `registerChain()`. |
| `SKILL.md` | This file |
| `AGENTS.md` | Injected loader |

## Usage

```typescript
import { dispatchOnce, registerChain } from "~/.claude/skills/snappy-chain/api.ts";
import bugReport from "~/.claude/skills/snappy-chain/chains/bug-report.ts";

registerChain("bug-report", bugReport);

const summary = await dispatchOnce({ limit: 20 });
console.log(summary.classified, summary.dispatched);
```

Dry run (classify + log, do not invoke handlers):

```bash
npx tsx ~/.claude/skills/snappy-chain/api.ts --dry
```

## Chain handler contract

```typescript
type ChainHandler = (event: Event, adapter: ChannelAdapter) => Promise<ChainResult>;

interface ChainResult {
  ok: boolean;
  intent: Intent;
  chain: string;
  event_id: string;
  source: string;
  outcome?: string;
  error?: string;
  post?: PostResult;
}
```

Handlers are channel-agnostic — they receive the source adapter and reply through it:

```typescript
await adapter.post(
  { source: e.source, channel_id: e.channel_id, thread_id: e.thread_id, to_user: null },
  { text: "Fixed in PR #123", files: screenshots },
);
```

## Dedup + idempotence

Every processed event — whether dispatched, dry-run, or had no handler — is stamped in `chain-processed.ndjson`. This means:

- Cron-driven dispatch is safe: re-running the same sweep won't re-fire handlers.
- Events with `intent = noise` are still marked processed (else every sweep re-classifies the same junk).
- Events whose handler errored are also marked processed. **Failed chains do not auto-retry.** Manual re-injection only — prevents runaway loops.

## Classifier (V1)

Pure keyword rules in `classify.ts`. Five intents. Deterministic.

**Upgrade path:** plug an LLM fallback via `snappy-dispatch` for events that don't match any rule (instead of defaulting to `noise`). Deferred until V1 shows us what it mis-classifies.

## Rules

1. **Handlers must be channel-agnostic.** They receive `(event, adapter)` and use only contract verbs. No hard-coded Slack calls inside a handler.
2. **No handler auto-publishes without contract-level intent.** Handlers post through `adapter.post()`, which honors per-channel publish rules (e.g. Gmail stays draft-only).
3. **Every dispatch logs a run summary.** No silent runs. The run log is the chain-level cert.
4. **Failed chains don't auto-retry.** Root-cause the failure, fix, manually re-inject if needed.
5. **Dedup is mandatory.** Handlers do not manage their own idempotence; the dispatcher does.

## Related skills

- `snappy-channel-contract` — the adapter shape this dispatcher consumes.
- `snappy-inbox-sweep` — the read backbone most adapters wrap.
- `snappy-dispatch` — where chain handlers offload grunt work (clone, grep, extract).
- `snappy-ops` — the operator shell that will eventually run `dispatchOnce` on a cron.

// snappy-chain/api.ts — Event-to-chain dispatcher
// Reads events across all registered channel adapters, classifies intent,
// routes to chain handlers, dedupes via processed log.

import { readdirSync, existsSync, appendFileSync, readFileSync, mkdirSync } from "node:fs";
import { join, dirname } from "node:path";
import { homedir } from "node:os";
import type {
  ChannelAdapter, Event, PostResult,
} from "../snappy-channel-contract/types.ts";
import { classify, classifyWithLLM, type Intent } from "./classify.ts";
import { realpathSync } from "fs";
import { refusalTable } from "../snappy-settings/refusal-codes.ts";

const SKILLS_ROOT = join(homedir(), ".claude/skills");
const PROCESSED_LOG = join(homedir(), ".claude/logs/chain-processed.ndjson");
const RUN_LOG = join(homedir(), ".claude/logs/chain-runs.ndjson");

export interface ChainResult {
  ok: boolean;
  intent: Intent;
  chain: string;
  event_id: string;
  source: string;
  outcome?: string;
  error?: string;
  post?: PostResult;
}

export type ChainHandler = (event: Event, adapter: ChannelAdapter) => Promise<ChainResult>;

const registry = new Map<Intent, ChainHandler>();

export function registerChain(intent: Intent, handler: ChainHandler): void {
  registry.set(intent, handler);
}

export function getRegistered(): Intent[] {
  return Array.from(registry.keys());
}

async function loadAdapters(): Promise<ChannelAdapter[]> {
  const out: ChannelAdapter[] = [];
  for (const d of readdirSync(SKILLS_ROOT)) {
    if (!d.startsWith("snappy-")) continue;
    const p = join(SKILLS_ROOT, d, "adapter.ts");
    if (!existsSync(p)) continue;
    try {
      const mod = await import(p);
      const a = (mod.adapter ?? mod.default) as ChannelAdapter | undefined;
      if (a?.source && typeof a.read === "function") out.push(a);
    } catch { /* skip broken adapters; kernel verify surfaces them */ }
  }
  return out;
}

function ensureLog(path: string) {
  if (!existsSync(dirname(path))) mkdirSync(dirname(path), { recursive: true });
}

function loadProcessed(): Set<string> {
  ensureLog(PROCESSED_LOG);
  if (!existsSync(PROCESSED_LOG)) return new Set();
  const seen = new Set<string>();
  for (const line of readFileSync(PROCESSED_LOG, "utf8").split("\n")) {
    if (!line.trim()) continue;
    try {
      const r = JSON.parse(line);
      seen.add(`${r.source}:${r.event_id}`);
    } catch { /* ignore malformed lines */ }
  }
  return seen;
}

function recordProcessed(r: ChainResult) {
  ensureLog(PROCESSED_LOG);
  appendFileSync(
    PROCESSED_LOG,
    JSON.stringify({
      source: r.source,
      event_id: r.event_id,
      intent: r.intent,
      chain: r.chain,
      ok: r.ok,
      ts: new Date().toISOString(),
    }) + "\n",
  );
}

function recordRun(summary: DispatchSummary) {
  ensureLog(RUN_LOG);
  appendFileSync(RUN_LOG, JSON.stringify(summary) + "\n");
}

export interface DispatchOptions {
  limit?: number;
  dryRun?: boolean;         // classify + log, do not invoke handlers
  sources?: string[];       // restrict to named sources
  llmFallback?: boolean;    // re-classify "noise" via snappy-dispatch
  llmModel?: string;        // model alias for fallback (default: gemini)
}

export interface DispatchSummary {
  ts: string;
  duration_ms: number;
  adapters: string[];
  read_total: number;
  skipped_seen: number;
  classified: Record<string, number>;
  dispatched: number;
  results: ChainResult[];
  errors: string[];
}

export async function dispatchOnce(opts: DispatchOptions = {}): Promise<DispatchSummary> {
  const t0 = Date.now();
  const adapters = (await loadAdapters())
    .filter((a) => !opts.sources || opts.sources.includes(a.source));
  const seen = loadProcessed();

  const summary: DispatchSummary = {
    ts: new Date().toISOString(),
    duration_ms: 0,
    adapters: adapters.map((a) => a.source),
    read_total: 0,
    skipped_seen: 0,
    classified: {},
    dispatched: 0,
    results: [],
    errors: [],
  };

  for (const a of adapters) {
    let events: Event[] = [];
    try {
      events = await a.read(undefined, opts.limit ?? 20);
    } catch (e) {
      summary.errors.push(`${a.source}: ${(e as Error).message}`);
      continue;
    }
    summary.read_total += events.length;

    for (const e of events) {
      const key = `${e.source}:${e.event_id}`;
      if (seen.has(key)) { summary.skipped_seen++; continue; }

      let intent = classify(e);
      if (intent === "noise" && opts.llmFallback) {
        intent = await classifyWithLLM(e, opts.llmModel);
      }
      summary.classified[intent] = (summary.classified[intent] ?? 0) + 1;

      const handler = registry.get(intent);
      if (!handler) {
        // noise / unregistered intent — mark processed so we don't re-classify forever
        const r: ChainResult = { ok: true, intent, chain: "noop", event_id: e.event_id, source: e.source, outcome: "no-handler" };
        summary.results.push(r);
        recordProcessed(r);
        continue;
      }

      if (opts.dryRun) {
        summary.results.push({ ok: true, intent, chain: handler.name || "anon", event_id: e.event_id, source: e.source, outcome: "dry-run" });
        continue;
      }

      try {
        const r = await handler(e, a);
        summary.results.push(r);
        summary.dispatched++;
        recordProcessed(r);
      } catch (err) {
        const r: ChainResult = {
          ok: false, intent, chain: handler.name || "anon",
          event_id: e.event_id, source: e.source, error: (err as Error).message,
        };
        summary.results.push(r);
        recordProcessed(r);
      }
    }
  }

  summary.duration_ms = Date.now() - t0;
  recordRun(summary);
  return summary;
}
/** WHAT THIS HAND ANSWERS, and what each verb does to the world.
 *  Derived from this file's own CLI dispatch by
 *  `snappy-hands/contract-derive.ts` — a verb the code does not implement is
 *  never declared here. Snappy's daemon reads it (`api.ts contract`) to
 *  validate every call, build the argument words in order, decide whether the
 *  act runs now or stages for the owner, and hand the child exactly the
 *  environment keys named in `requires` — never a value, never anything else.
 */
export const HAND_CONTRACT = {
  skill: "snappy-chain",
  description: "Event-to-chain dispatcher. Reads all registered channel adapters, classifies intent, routes to chain handlers. Triggers on mentions of chain, chain handler, event routing, chain dispatch, or intent classification across channels.",
  managed: false,
  requires: [] as string[],
  refusals: refusalTable("unknown_verb"),
  verbs: {
  },
} as const;

if (import.meta.url === `file://${realpathSync(process.argv[1])}` && process.argv[2] === "contract") {
  console.log(JSON.stringify(HAND_CONTRACT, null, 2));
  process.exit(0);
}


if (import.meta.url === `file://${realpathSync(process.argv[1])}`) {
  (async () => {
    const dry = process.argv.includes("--dry");
    const llm = process.argv.includes("--llm");
    const s = await dispatchOnce({ dryRun: dry, limit: 10, llmFallback: llm });
    console.log(JSON.stringify(s, null, 2));
    process.exit(s.errors.length ? 1 : 0);
  })();
}

// snappy-chain/chains/bug-report.ts — V1 bug-report handler
//
// Scope: when a bug-report event arrives, open a GitHub issue and reply in
// thread with the issue URL. No auto-fix, no PR, no clone. The triage is
// human-in-the-loop by design — this chain exists to prove the contract pays
// off on a safe, reversible action.
//
// Future v2: add an auto-fix loop (clone → repro → fix → PR → screenshots)
// behind an explicit flag.

import type { ChannelAdapter, Event } from "../../snappy-channel-contract/types.ts";
import { createIssue } from "../../snappy-github/api.ts";
import { env } from "../../snappy-settings/load.ts";
import type { ChainHandler, ChainResult } from "../api.ts";

function inferRepo(e: Event): { owner: string; repo: string } {
  const explicit = e.text.match(/\b([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)\b/);
  if (explicit && !explicit[1].includes(".")) {
    return { owner: explicit[1], repo: explicit[2] };
  }
  const fallback = (() => {
    try { return env("BUG_REPORT_DEFAULT_REPO"); } catch { return ""; }
  })();
  const [owner, repo] = (fallback || "robertboulos/snappyClassroomContent").split("/");
  return { owner, repo };
}

function buildTitle(e: Event): string {
  const first = (e.text.split("\n")[0] || "").trim().slice(0, 100);
  return first ? `[${e.source}] ${first}` : `[${e.source}] bug report from ${e.author.display}`;
}

function buildBody(e: Event): string {
  return [
    `**Reported by:** ${e.author.display} (${e.author.handle})`,
    `**Channel:** ${e.channel_name} (${e.source})`,
    `**When:** ${e.ts}`,
    e.permalink ? `**Source:** ${e.permalink}` : null,
    "",
    "---",
    "",
    e.text,
    "",
    "---",
    "",
    "_Filed automatically by snappy-chain bug-report handler._",
  ].filter((l) => l !== null).join("\n");
}

const bugReport: ChainHandler = async (event, adapter): Promise<ChainResult> => {
  const { owner, repo } = inferRepo(event);
  try {
    const issue = await createIssue(owner, repo, buildTitle(event), buildBody(event), ["bug", "auto-filed"]);
    const issueUrl = (issue as any)?.html_url ?? `https://github.com/${owner}/${repo}/issues/${(issue as any)?.number}`;

    const post = await adapter.post(
      { source: event.source, channel_id: event.channel_id, thread_id: event.thread_id, to_user: null },
      { text: `Filed as ${issueUrl} — I'll follow up when there's a fix.` },
    );

    return {
      ok: true,
      intent: "bug-report",
      chain: "bug-report",
      event_id: event.event_id,
      source: event.source,
      outcome: `issue=${issueUrl}`,
      post,
    };
  } catch (err) {
    return {
      ok: false,
      intent: "bug-report",
      chain: "bug-report",
      event_id: event.event_id,
      source: event.source,
      error: (err as Error).message,
    };
  }
};

export default bugReport;

// snappy-chain/chains/question.ts — V1 question handler
//
// Scope: draft a reply via snappy-dispatch and queue it for Robert to
// review. Never auto-posts. The draft goes to ~/.claude/logs/chain-drafts.ndjson
// where the ops shell can surface it.

import { appendFileSync, existsSync, mkdirSync } from "node:fs";
import { dirname, join } from "node:path";
import { homedir } from "node:os";
import type { ChannelAdapter, Event } from "../../snappy-channel-contract/types.ts";
import { dispatch } from "../../snappy-dispatch/api.ts";
import type { ChainHandler, ChainResult } from "../api.ts";

const DRAFT_LOG = join(homedir(), ".claude/logs/chain-drafts.ndjson");

function buildPrompt(e: Event): string {
  return [
    "You are drafting a short, direct reply to a question Robert received.",
    "Rules:",
    "  - Answer the question if you can. If you can't, say what info is needed.",
    "  - Plain prose, 1-3 sentences. No greeting, no signoff.",
    "  - Never invent facts. Never promise specific timelines.",
    "",
    `Channel: ${e.source} (${e.channel_name})`,
    `From: ${e.author.display}`,
    "",
    "Question:",
    e.text.slice(0, 2000),
    "",
    "Draft reply:",
  ].join("\n");
}

function saveDraft(entry: object) {
  if (!existsSync(dirname(DRAFT_LOG))) mkdirSync(dirname(DRAFT_LOG), { recursive: true });
  appendFileSync(DRAFT_LOG, JSON.stringify(entry) + "\n");
}

const question: ChainHandler = async (event, _adapter): Promise<ChainResult> => {
  try {
    const r = await dispatch({
      prompt: buildPrompt(event),
      model: "gemini",
      tools: [],
      timeoutMs: 30_000,
    });
    if (!r.ok) {
      return {
        ok: false,
        intent: "question",
        chain: "question",
        event_id: event.event_id,
        source: event.source,
        error: r.error || "dispatch failed",
      };
    }
    const draft = (r.output || "").trim();
    saveDraft({
      ts: new Date().toISOString(),
      source: event.source,
      event_id: event.event_id,
      channel_id: event.channel_id,
      thread_id: event.thread_id,
      author: event.author,
      question: event.text,
      draft,
      permalink: event.permalink,
    });
    return {
      ok: true,
      intent: "question",
      chain: "question",
      event_id: event.event_id,
      source: event.source,
      outcome: `draft-saved (${draft.length} chars)`,
    };
  } catch (err) {
    return {
      ok: false,
      intent: "question",
      chain: "question",
      event_id: event.event_id,
      source: event.source,
      error: (err as Error).message,
    };
  }
};

export default question;

// snappy-chain/classify.ts — Intent classifier
// V1: keyword rules. Deterministic, explainable, zero latency.
// Upgrade path: add an LLM fallback via snappy-dispatch for ambiguous events.

import type { Event } from "../snappy-channel-contract/types.ts";
import { dispatch } from "../snappy-dispatch/api.ts";
import { realpathSync } from "fs";

export type Intent =
  | "bug-report"
  | "question"
  | "feature-request"
  | "ack"
  | "noise";

const VALID_INTENTS: Intent[] = ["bug-report", "question", "feature-request", "ack", "noise"];

interface Rule {
  intent: Intent;
  patterns: RegExp[];
}

const RULES: Rule[] = [
  {
    intent: "bug-report",
    patterns: [
      /\b(bug|broken|borked|error|crash|not working|doesn'?t work|isn'?t working|failing|fails|regression|stuck|hang|hangs|exception|stack trace|500|nullpointer|undefined is not|blocker|blocked on|breaks|breaking)\b/i,
    ],
  },
  {
    intent: "feature-request",
    patterns: [
      /\b(can (you|we) add|feature request|wishlist|would be (nice|great|cool) if|it'?d be (nice|great) if|please add|support for|we need|could (you|we) (add|support))\b/i,
    ],
  },
  {
    intent: "question",
    patterns: [
      /\?\s*$/,
      /\b(how do|how can|how does|what'?s the|where is|why is|can i|should i|any ideas?|thoughts\??|any chance)\b/i,
    ],
  },
  {
    intent: "ack",
    patterns: [
      /^\s*(re:\s*)?(thanks|thank you|ty|cool|nice|great|awesome|perfect|got it|ok|okay|sounds good|sg|\ud83d\udc4d|\ud83c\udf89)\b/i,
      /\b(really )?appreciate (it|that|you|the)\b/i,
      /\b(thanks|thank you) (so much|again|for)/i,
    ],
  },
];

export function classify(e: Event): Intent {
  const text = (e.text || "").trim();
  if (!text) return "noise";
  for (const rule of RULES) {
    for (const p of rule.patterns) if (p.test(text)) return rule.intent;
  }
  return "noise";
}

// LLM fallback: only call when keyword rules returned noise AND the caller
// explicitly opts in. Strict single-label prompt, validated output, defaults
// back to "noise" on any parse failure. Uses snappy-dispatch (default: gemini).
export async function classifyWithLLM(e: Event, model = "gemini"): Promise<Intent> {
  const kw = classify(e);
  if (kw !== "noise") return kw;
  const text = (e.text || "").trim();
  if (!text) return "noise";

  const prompt = [
    "Classify this message into EXACTLY ONE of these labels:",
    "  bug-report       — something is broken, failing, or producing errors",
    "  question         — asking how to do something or requesting info",
    "  feature-request  — asking for new capability or enhancement",
    "  ack              — thanks, confirmation, short acknowledgment",
    "  noise            — marketing, auto-reply, calendar, shipping, anything not actionable",
    "",
    "Reply with the label only. No punctuation. No explanation.",
    "",
    `Message (${e.source}, from ${e.author.display}):`,
    text.slice(0, 2000),
  ].join("\n");

  try {
    const r = await dispatch({ prompt, model, tools: [], timeoutMs: 30_000 });
    if (!r.ok) return "noise";
    const label = (r.output || "").trim().toLowerCase().replace(/[^a-z-]/g, "");
    return (VALID_INTENTS as string[]).includes(label) ? (label as Intent) : "noise";
  } catch {
    return "noise";
  }
}

if (import.meta.url === `file://${realpathSync(process.argv[1])}`) {
  const samples = [
    "the sweep is broken, keeps throwing an error",
    "how do I set up a new adapter?",
    "thanks, that worked perfectly",
    "can you add support for discord?",
    "lol",
  ];
  for (const s of samples) {
    const fake: Event = {
      source: "slack", event_id: "t", thread_id: null, channel_id: "c",
      channel_name: "test", author: { id: "u", handle: "u", display: "u" },
      text: s, ts: new Date().toISOString(), permalink: null, meta: {},
    };
    console.log(classify(fake).padEnd(16), s);
  }
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { HAND_CONTRACT } from "./api.ts";
import { REFUSAL_CODES, type RefusalCode } from "../snappy-settings/refusal-codes.ts";

/** RULE 33 COVERAGE, AGAINST THE ONE CLOSED TABLE ⟨lane r30, 2026-09-09⟩.
 *  This file used to restate a refusal row's own properties — that it has a
 *  `contract_slice`, that it has a `fix`, that it leaks no token — once per
 *  hand, 48 times, over rows that all come from the SAME object. Forty-eight
 *  copies of one check is the duplicate road the closed table exists to end:
 *  `snappy-settings/refusal-codes.test.ts` runs those checks ONCE over every
 *  row, and the second test below proves this hand carries THE ROW ITSELF and
 *  not a copy — an identity a drifted duplicate cannot fake. Before this, each
 *  hand hand-wrote its own row, and the wording had already drifted: the
 *  inline `unknown_verb` said "Call one of the verbs named in
 *  HAND_CONTRACT.verbs" while the closed table says "Call one of the verbs the
 *  contract declares; the refusal lists them."
 *
 *  DECLARED stays a literal list, deliberately. It is this hand's coverage
 *  manifest and it is what rule 33's lint reads out of the test SOURCE to ask
 *  "did a person look at this code" — deriving it from Object.keys would make
 *  the test pass for a hand with no refusals at all. `satisfies readonly
 *  RefusalCode[]` makes the compiler refuse a name the one table does not
 *  have. It NAMES codes; it no longer DEFINES them. */
const DECLARED = [
  "unknown_verb",
] as const satisfies readonly RefusalCode[];

test("snappy-chain: the refusal table declares exactly the codes this test names", () => {
  assert.deepEqual(Object.keys(HAND_CONTRACT.refusals ?? {}).sort(), [...DECLARED].sort());
});

test("snappy-chain: every declared refusal is the one closed table's own row, never a copy", () => {
  const declared = Object.entries(HAND_CONTRACT.refusals ?? {});
  assert.ok(declared.length > 0, "HAND_CONTRACT.refusals is empty");
  for (const [code, row] of declared) {
    assert.ok(code in REFUSAL_CODES, `${code} is not a row of snappy-settings/refusal-codes.ts`);
    assert.equal(row, REFUSAL_CODES[code as RefusalCode], `${code} is a copy of the closed table's row, not the row itself`);
  }
});