Skill jam-proof-table

jam-proof-table

Many claims in, one table out: each thing you say works or is broken, its status, and the Jam that shows it. The user should be able to check every claim in one click without asking "where's the Jam for this?".

To record a new Jam, use jam-proof. This skill names, files, checks and reports the Jams.

Set up the CLI

command -v jam >/dev/null || echo "jam is not installed"
export PATH="$HOME/.local/bin:$PATH"
jam auth status --json || jam auth login

If jam is not on PATH, stop and ask the user to install it from https://jam.dev/docs/cli, then continue. Do not install it yourself.

Exit code 3 means not signed in. With no browser (CI, a cloud agent), ask the user to set JAM_TOKEN to a personal access token from https://jam.dev/s/settings/mcp as a secret. Never write a token to a file. jam agent-context prints every command and flag.

1. One claim, one Jam

A row is one claim: "the price no longer truncates", "sign-in works after sign-out". Each row gets a Jam that shows that claim. When one Jam covers several claims, give each row the time it shows up (at 0:48).

A claim with no Jam stays in the table as "not recorded". Never list a local video file or screenshot path as a Jam.

2. Name and file every Jam

Titles are how people find Jams later. Use <ticket or source> <what it shows>. A Jam that checks a fix for an earlier Jam reuses that Jam's title with "fix check: " in front, so both show up in one search.

jam list folders --query "Release 4.2 checks" --json      # reuse it if it exists
jam create folder "Release 4.2 checks" --json             # otherwise; returns its id
jam update jam "$ID" --folder "$FOLDER_ID" --title "ENG-412 fix check: Pro price wraps"

jam create folder makes a new folder on every call, even with a name that exists, so look first and pass the id afterwards. One folder per run. Creating a folder can upgrade a Viewer to a Creator, which can change seat billing; on a Viewer account, ask first. Rename and move only the Jams this run recorded, unless asked.

3. Find Jams that already exist

Before recording again, look for the Jam. A run's folder is the most reliable way to find all of its Jams:

jam list folders --query "checks" --json
jam list jams --folder "$FOLDER_ID" --json
jam list jams --created-at -P1D --json                    # created in the last day
jam list jams --query "price" --order-by createdAt --limit 20 --json
jam list jams --url "https://example.com/pricing" --json

--query is a fuzzy search, not a title filter: read each title before using a hit. --order-by createdAt lists newest first, so --limit drops the oldest.

"What was the Jam I gave you?" means the conversation first: search it for jam.dev/c/ before searching the workspace.

4. Check each Jam before listing it

jam get jam "$ID" --json                                  # reads back, type, duration

Then check it by its type; the other types have no video frames:

jam get frames "$ID" --at 48000 --size medium --out "$(mktemp -d)"   # video; outside the repo
jam get screenshots "$ID" --out "$(mktemp -d)"                       # screenshot

A replay has no frames or screenshots: check it in its events, console and network, and mark the row unconfirmed when they cannot settle the claim.

For a video, open the frame at the moment the claim shows up; --at must be below the Jam's duration. A blank page, a single frozen frame, or the wrong tab is not proof. A screenshot is one still image by design: it is proof when the claim is visible in it. When the Jam does not show the claim, record it again with jam-proof and say that you did.

Some claims happen off screen: an API status, a count, a sent message. Check those in jam get network, jam get console or jam get user-events, and say in the table which part the video shows and which part the events show.

5. Write the table

Keep the order the work was done in. Status is the claim's, one of: works, broken, unconfirmed (the Jam does not settle it), not recorded.

| # | Claim | Status | Jam | Source |
|---|-------|--------|-----|--------|
| 1 | Pro price wraps on narrow cards | works | [ENG-412 fix check](https://jam.dev/c/...) | [ENG-412](...) · [original Jam](https://jam.dev/c/...) |
| 2 | Sign-in after sign-out | broken | [ENG-415 repro](https://jam.dev/c/...) | [ENG-415](...) |

Under the table, one line per row that is not "works", saying why.

After

Offer one comment on each original Jam whose row settles something (works or broken), with the status and the link to its fix check. Skip unconfirmed and not-recorded rows:

jam create comment "$ORIGINAL_ID" "Fix check: works. https://jam.dev/c/<id>"

Post on a yes, or right away when the user already asked.

Mark a fix check as the fix of its original Jam only when its row says works (markRelated over MCP); the original then shows a "fixed by" backlink:

jam update jam <fix check id> --mark-related "$ORIGINAL_ID" --type fixes

Use --type proves for a Jam that shows a claim rather than a fix. A broken or unconfirmed row gets --type relates_to at most, never fixes.

Post the table in chat. Post it to a pull request or ticket only when the user asks.

Send feedback to Jam

When this skill, a Jam MCP tool, a jam command or a Jam doc was wrong, stale or confusing, or worked unusually well, tell Jam. Send it yourself: Jam's agents read it, so it needs no approval.

Call the submitFeedback MCP tool with body, category and subject.

When MCP is unavailable, use the CLI:

jam feedback "<what you were doing, what you expected, what happened, the mistake>" --category <skills|mcp|cli|docs> --subject <skill name, tool name or command>

• Jam surfaces only, not the user's code or other tools.
• At most once per session, and never for a slip you corrected yourself.
• No secrets, customer data, source code, stack traces or recording content.