Acceptance

Acceptance (Builder Self-Evidence)

You are the builder for a delivery. A separate review step judges it against a plan — checks you author, or a verify plan handed to this run. A check that declares requiredEvidence cannot pass on your text alone: a missing artifact marks it uncertain and holds the delivery.

author (or discover) the plan  →  pick the surface  →  capture evidence  →  publish the round  →  self-check coverage

Read the project layer first

Before touching an environment, check for .agents/acceptance/:

The project layer owns how this repository is run; this skill owns what a valid round is (plan, evidence, report, immutable round, the hard rule). On running, the project layer wins; on what may be published, this skill wins. Never invent a start command, port, or auth flow PROJECT.md answers; fix a divergence in the adapter during the run instead of working around it. No .agents/acceptance/ → bootstrap one first: project-adapter.md.

Living logs — inject each by its own shape

Both layers (this skill's generic copies and the project's own) are loaded once the target is known, silently:

• common-mistakes.md — read its Checklist in full, now and again before marking any case pass. Pull an entry by id only when a checklist line applies to a case.
• probe-mock-patterns.md — read the heading index, then pull only the entries this round needs. Pick by meaning, not keyword; rg over the body is the fallback.

rg -n '^#{2,4} ' <file>          # the index, with line numbers
sed -n '<start>,<end>p' <file>   # one entry, in full

Record new project-specific learnings in the project layer only.

Two paths — no id is required

Every evidence command targets a round. The authored path is the default; you have an operation id only when the invocation names one. Never hunt the environment for one, and never report this skill inapplicable — a round without an operation is simply recorded as standalone.

Pass --subject (task:<id> / topic:<id> / document:<id>) only when the caller named one; otherwise ingest attaches the round itself when it can and creates a standalone acceptance when it cannot. On the first ingest, always supply --requirement "<one-sentence business goal>" — the durable goal of the whole acceptance, not this round's scope; it is immutable once recorded.

Prerequisites: lh is authed (lh acceptance run list --json returns [] or data; an auth error means stop and surface it), and only the UI driver the selected surface needs is installed — probe before adding dependencies, and never substitute a private agent plugin.

HARD RULE — programmatic gates are NEVER acceptance checks

Every check MUST be an outcome a person decides about the delivery: what the user sees, hears, reads, or receives. These MUST NOT appear as a check, under any phrasing: unit / integration / regression / snapshot tests, coverage, type-check / tsc, lint / eslint, format, "compiles", "build passes", "CI is green". Run them, then report them as one line of narrative.

Enforced at ingest: every matching item (matched on title, category, AND method — "run bun run test" under a product-sounding title still matches) is dropped with a warning and summary recounted; a round of only such checks fails to publish. The line is the subject of the check, not who judged it: a CLI behavior asserted by a command is a fine check (verifier: "program"); "the suite is green" is not. Before writing any plan, ask of each draft check: would the user click accept/reject on this?

Rounds are immutable — repair means a NEW round

A published round is a permanent record. Never re-submit into a round after changing the code — publish the re-verification as the next round and let the acceptance page show the progression.

Before a repair round, read the aggregate with lh acceptance view <acceptanceId | type:id> --json. Omit checks whose latest userReview.action is accept; address non-stale rejects under their exact stable ids; when a check semantically replaces another, declare supersedes: ['old-id'] and repeat the full lineage in every later round that reuses the successor id. Pass --acceptance <acceptanceId> so the round joins the same history.

Rules you will be tempted to skip

Not judgment calls — the moves an agent under pressure makes and must not. Each excuse below was made in a real round.

Pick the surface by what you changed

Match the change to the cheapest surface that can prove it; escalate only if needed.

• Don't open a browser for a backend change; command output as text is the strongest, cheapest proof. Use Electron only when the criterion depends on desktop-only code; iOS is driven by a Simulator HID/AX CLI, never host mouse — mark the case blocked if the CLI cannot express the gesture.
• Structured data uses native visualizations (cases[].datasets + cases[].visualizations; raw CSV/JSON stays as evidence), not a PNG — report.md. A deliverable the user hears needs audio — evidence.md.
• Auth is a gate scoped to the surface: authenticate that surface first or every capture lands on the sign-in page. Web: auth-web.md.
• A UI round may price its interaction cost by recording KLM operator counts into interaction-trace.jsonl; optional, never hand-written — interaction-cost.md.

Shared rules for every artifact — media types, provenance, file vs inline, safety — are in evidence.md.

Final handoff (mandatory)

Before declaring the task done, prove coverage: for each check with requiredEvidence, every declared type is present at least once. Report it explicitly; a missing type holds the delivery at uncertain no matter how good the work is.

The final response MUST include the published acceptance URL together with the coverage result — never only a check-result id or a prose claim. Expose only the acceptance (/acceptance/<acceptanceId>), the stable cross-round decision surface; append ?r=<roundIndex> for this round's fixed snapshot. Put no images, local paths, local file links, or internal run-page paths in the chat reply.

Acceptance:   https://app.lobehub.com/acceptance/<acceptanceId>
Coverage: 2/2 criteria, all required evidence uploaded

Portability rules

• Engine-level capture over OS capture. agent-browser screenshot / dom / eval run headless; screencapture / osascript are macOS-only. iOS: xcrun simctl io over host-window capture. Rounds land under .acceptances/, which the CLI keeps out of git.
• Upload as you go. Evidence keyed to its check mid-run survives a crash near the end.
• Don't invent evidence. Capture only the types a check declares.

Reference map