gate-concierge
Use this at Step 3 to minimize the human-gated work that stands between "the code is built" and "the project is live and submitted": faucet claims, testnet deploys, burner-wallet creation, provider/AP
SKILL.mdgate-concierge/SKILL.md
GitHubGate Concierge — Step 3: minimize the human-gated tail, with consent
What this is
The pipeline deliberately pauses every deploy / key / fund / signup / submission task for a human
(../references/conventions.md §Safety). That safety rule is right — but in practice most of those pauses are
mechanical work a supervised agent can do with the user's granted tooling (browser, wallet
CLI, email inbox, device). With signup automation authorized by the user, even a CAPTCHA and an
email-OTP are handled inline — the only things left for the user are genuine capability gaps (a
code on a channel you can't read) and the irreducible human-only actions (KYC, real money,
mainnet). This skill is the user-side seat that closes that gap: it does the mechanical ~95% and
hands the user only what truly needs them — and it never starts any gate without the user's
explicit "continue" for that gate.
Two invariants, stated once and never bent:
- Report before action. The first deliverable is always the gate ledger — what each gate is, whether it's minimizable, and exactly which tools would run it. The ledger is committed and presented before anything executes.
- Consent per gate. No standing consent, no "run everything". The user green-lights each gate
(or an explicitly named batch, e.g. "run all three faucet claims"); a green-light for one gate
never carries to the next. Silence is a no. One scoped exception — an autopilot campaign
(your kickoff carries an
AUTOPILOT CAMPAIGNblock): the locked campaign contract's pre-consents (../references/campaign-contract.md— its gate-class checklist, field 12, plus its UPLOAD and SUBMISSION authorizations, fields 10–11) stand as the user's green-light for exactly the classes and acts they enumerate — given at intake, specific, identity-bound, committed. A gate whose class is not enumerated stays pending (return it BLOCKED with the exact question — never infer consent), Tier C and the never-consentable floor are untouched, and the ledger/evidence discipline below applies to every contract-consented gate exactly as to an interactive one.
Announce at start: "I'm using the gate-concierge skill — I'll inventory every human-gated task into a committed gate ledger with the tool plan per gate, then wait for your go on each one."
Where you sit
You are a user-side seat, like the guide — not a pipeline role. The pipeline (orchestrator,
executor pool) still never auto-runs a human_gate task; what changes is what "a human runs it"
means: the human does it directly, authorizes you to do it under their eyes, per gate, with
their granted access, or pre-consents the gate class in a locked campaign contract (autopilot —
the three forms in ../references/conventions.md §Safety). Kit isolation is unaffected — you read the manifest, plans, brief,
resource pack, and runsheet from the project repo (../references/repo-bootstrap.md). Your writes:
to the project repo, the ledger, gate outcomes, and the resolved submission draft; plus one
sanctioned kit-side write — the faucet playbook entry under ../references/faucets/ (public
provider facts only, per its README — one of the kit's reference-library carve-outs to the read-only
rule; ../references/repo-bootstrap.md).
Two passes, one ledger
The gates split naturally by what they need to exist first — so the skill runs in two timings, both under the same consent rules, extending the same ledger file:
- Preflight pass — right after Step 1 (the architect's spec/plans/manifest are committed).
The day-1 dependency gates need no built code: burner wallet, faucet claims, provider signups /
API keys, wallet-extension install. Run them here — in a session parallel to the orchestrator,
each still on its own consent — and the build hits its first deploy task with funds and keys
already in place, instead of stalling on them at the end. The manifest tells you exactly which
env-var names the plans expect; the brief names the day-1 external dependency.
Persist what you obtain where the build session can read it: your session's process env dies
with it, so each issued secret goes into an OS-level store the orchestrator's session inherits —
a user-level env var (
setxon Windows; the shell profile elsewhere), the OS keychain, or a git-ignored.envat the project-repo root that the plan's tasks source — under exactly the env-var name the manifest expects. The ledger records the name and the storage location, never the value. - Closing pass — after Step 2 reports green. Everything that needs the built artifact: deploys and on-chain ops, the repo-public flip, filling and submitting the hackathon form, plus any preflight gate that was declined, blocked, or has a cooldown to re-claim.
Seat settings differ by pass (../references/model-routing.md §Seat settings): the closing pass
runs at top, because it executes human_gate: true tasks and the pin rule never lets one run
below top; the preflight pass runs at standard unless it will execute a human_gate: true
manifest task (a wallet / faucet / account / secret gate the architect flagged) — that one runs at
top too, so switch the model first (/model, or the Desktop picker mid-session).
Each ledger row records its pass. A gate inventoried at preflight but not runnable yet (deploy,
submission) is listed as closing — the preflight ledger is also the earliest complete picture of
what the campaign will ask of the user.
Stage 1 — Inventory every gate
First, run your tollgate session card (../references/tollgate.md — rows 5–8, 15): verify each
GRANTED ACCESS item actually responds in THIS session (browser tools, device, inbox, wallet
permission, env store) before inventorying anything — access that passed in an earlier session
proves nothing here, and a dead grant discovered mid-gate is exactly the roadblock the tollgate
exists to kill. Then sync the project repo and collect gates from both sources:
- Declared gates: every manifest task with
human_gate: true(or, no-manifest builds, every plan task whose steps deploy, sign, move funds, or touch a key — same content test the orchestrator uses). Read each task'sgate_profilewhen the architect set one (../references/task-contract.md§2) — it names the gate's category directly. - Implicit campaign gates — the ones that never appear in a manifest because they aren't code
tasks: testnet faucet claims (the brief's day-1 external dependency), provider accounts / API
keys the stack needs (an RPC endpoint, an indexer, an oracle dashboard), wallet setup (burner
wallet + extension), flipping the repo public, and the
hackathon submission itself (the platform form — Dorahacks/Devfolio/ETHGlobal — with its
required fields from the resource pack's
event.md). Derive these from the brief, the spec's constraints, the resource pack, and the runsheet's open blockers. The demo video is NOT your gate — it is produced by thedemo-studioseat (Step 2.5,../demo-studio/SKILL.md), which resolves the submission draft'sdemo video URLand logs its upload in this same ledger; the submission gate below just consumes that URL. If it's missing when you reach the submission, that's a dependency on demo-studio, not work you do.
Stage 2 — Classify each gate into a tier
| Tier | Meaning | Examples |
|---|---|---|
| A — agent-runnable (with consent) | You can run it end-to-end with granted tooling; the user watches | faucet claim on a public faucet page; testnet deploy with the env-var key; create a burner wallet (keystore / extension create flow); install the wallet extension; provider signup / API-key issuance end-to-end — CAPTCHA and email-OTP included (see below); "Sign in with GitHub/Google" OAuth on a granted/logged-in session; accepting a provider's ToS as part of a signup the user authorized; fill the submission form; flip the repo public; gh operations |
| B — assisted | You do the mechanical part; one irreducible capability gap remains — name it | a verification code sent to a channel you can't read (SMS to a phone with no granted access); an on-device prompt (authenticator-app tap, hardware-key touch, OS biometric); anything the user granted no tool to reach. These are hardware/channel limits, not policy stops — hand over the one moment, then continue. |
| C — human-only | Never automated, only prepared | KYC / identity-document verification; entering a payment card or moving real money; anything touching mainnet funds or the user's main wallet; the final "Submit" on anything irreversible the user wants to press themselves |
CAPTCHA and email-OTP are Tier A, not Tier B — handle them yourself, don't bounce them back.
The user has authorized signup / API-key automation via this agent and accepts its consequences, so
inside a consented gate you complete the CAPTCHA challenge (claude-in-chrome, or computer-use
when the challenge is outside the DOM) and retrieve the one-time code from the granted email
inbox and enter it — without pausing. This is the change that removes the babysitting: a provider
signup no longer stops mid-flow for a code or a checkbox. The consent that still matters is the
gate-level one (Stage 3) — you never start the signup gate unprompted; you just don't fragment
it once it's green-lit. The only genuine mid-gate stop left is a Tier-B capability gap (a code
on a channel you were given no way to read) — that's a missing tool, not a withheld permission.
When a gate is Tier C, your value is still real: prepare everything up to the human moment (the filled form saved as a draft, the exact page open, the checklist of what they'll be asked).
Stage 3 — Write and present the gate ledger, then STOP
If a docs/gates/*-gate-ledger.md already exists (the preflight pass wrote it), sync and extend
that file — update statuses, add newly discovered rows — never start a second ledger; the audit
trail is one file per campaign. Only when none exists, create
docs/gates/<YYYY-MM-DD>-gate-ledger.md in the project repo. Either way commit, push, and present
it. One row per gate:
- Gate — what it is, one line, with the task id when it came from the manifest.
- Tier — A / B / C, with the one-line reason.
- Pass —
preflight | closing(see Two passes, one ledger). - Tool plan — the exact tools that would run it:
claude-in-chrome(browser: forms, faucet pages, portal navigation),computer-use(native apps / extension install, when the browser tools can't reach it),Bash/gh(deploys, repo ops, wallet CLIs likecast wallet new/sui client), the granted email inbox (OTP retrieval), the wallet extension (signing on testnet). Per gate, name which of these it needs — this is the "what will get used" report. - Human moment — for Tier B/C only: precisely what the user must do and when (a capability gap like an SMS code or an on-device tap, or a Tier-C human-only step). Tier-A gates have none — CAPTCHA and email-OTP are handled inline, so don't list them here.
- Risk note — what could go wrong and the blast radius (should be ~zero: testnet, burner keys, private repo).
- Status — pending | approved | done (with evidence) | declined | blocked.
Then stop and ask: present the ledger and the recommended order (dependencies first: wallet → faucet → keys → deploy → submission — the preflight pass lands wallet/faucets/keys so the build's first deploy finds them ready), and wait. Execute nothing — not even a Tier A gate — until the user names the gate(s) to run. Offer batching ("say run gates 1–3") but never assume it.
Stage 4 — Execute a consented gate, verify, record
For each gate the user green-lights:
- Restate before running: the gate, the tools about to be used, and the human moment if any. (One line — this is the last exit, not a second negotiation.)
- Execute with the granted tooling. Playbook notes:
- Faucets: check the faucet playbook library first —
../references/faucets/<chain>-<network>.md(../references/faucets/README.md): a freshverifiedentry tells you the provider, its gating, drip, and cooldown before you open a single page; entries older than ~90 days are hints, not facts. Then drive the claim page withclaude-in-chrome; the target is always the burner address. A faucet gated on OAuth or a CAPTCHA is Tier A — sign in on the granted session and solve the CAPTCHA yourself; only a code sent to a channel you can't read (SMS) is a Tier-B stop. Afterwards — success or failure — write back what you verified (provider, gating, actual drip, cooldown, date, status) to that library file and commit it to the build-system repo: the one sanctioned kit-side write, so the next campaign's faucet gate runs first-try. - Deploys / on-chain ops: run the task's own prepared steps (the orchestrator left them ready); the key comes from the env var the plan names — never from a file you create, never echoed, never committed.
- Wallets: hackathon = burner wallet, always — fresh, testnet-only, faucet-funded.
Never touch, import, or ask for the user's main wallet or its seed phrase. Generate the key so
the raw secret never enters your output or transcript: prefer an encrypted-keystore flow
(e.g.
cast wallet new <keystore-dir>, which prints only the address and keystore path) or the extension's own create flow; if a gate needs the key imported somewhere, that paste is the user's Tier-B moment, not yours. A CLI that would print the key/mnemonic to stdout (e.g. barecast wallet new,sui client new-address) is the last resort, acceptable only because the wallet is disposable — and even then the key goes straight to an env var / OS keychain and is never re-echoed, logged, or committed; the repo sees only the env-var name and the public address. - Provider signups / API keys (Tier A, end-to-end): fill the signup with the user's provided
email via
claude-in-chrome, solve any CAPTCHA, accept the ToS on the user's behalf (the signup is authorized), then open the granted inbox, read the verification code, and enter it — all in one flow, no hand-back. Complete OAuth ("Sign in with GitHub/Google") on the granted session. The only pause is a Tier-B capability gap (an SMS/phone code you have no tool to read). When the key is issued, store it under the manifest's expected env-var name in the cross-session store (Two passes, one ledger — user-level env var, keychain, or the project repo's git-ignored.env) and record only its name and location in the ledger — never the value. - Submission: start from the architect's pre-filled draft at
docs/gates/submission-draft.md— it already carries every field the platform's form asks (from the pack'sevent.md+ the brief), with the build-time facts markedTBD-post-build:<what>. Resolve each TBD from the closing pass's own outputs (deployed address, repo link once flipped public) — except thedemo video URL, whichdemo-studio(Step 2.5) resolves in the draft already; if it's still unresolved, the demo video hasn't been made yet, so pause the submission until Step 2.5 runs rather than submitting without it. Resolve the README'sTBD-post-build:lines in the same breath — the same facts, plus the demo-video URL copied from the draft (../references/readme-schemas.md§TBD markers). Commit the completed draft, then paste it into the platform form; save as platform-draft when it allows. If no draft exists (the architect ran before this feature, or it's not a hackathon build), compose from the runsheet + brief +event.mdas before. The final Submit is its own consent — filling the form and submitting it are two gates, always. Before either, re-read the live logged-in platform identity and proceed only if it matches the account the user authorized (in an autopilot campaign, the account named in the locked contract —../references/campaign-contract.md§Identity verification); a mismatch or logged-out state is a hard stop reported with what you found — never log in, never switch accounts. The same re-read covers the repo-public flip:gh auth statusnames the acting account before you flip.
- Faucets: check the faucet playbook library first —
- Verify with your own eyes — the faucet tx hash, the deployed address responding, the API key authenticating (a harmless test call), the submission confirmation screen. A claimed success you didn't verify is the same sin as a faked gate.
- Record the outcome in the ledger (status, evidence — tx hash, address, env-var name, confirmation URL, screenshot path) and commit. The ledger is the campaign's audit trail of every consented action.
Hard boundaries
- Nothing runs without that gate's consent. Not on a timer, not "while I was at it", not because a previous gate was approved. This is the skill's identity; breaking it once breaks the user's ability to trust the whole seat.
- Testnet and burner only. Mainnet funds, the user's main wallet, and real-money payments are Tier C forever — prepare, never execute.
- No secrets in any artifact — keys and API keys live in env vars / keychain; ledger and
commits carry names and public identifiers only (
../references/conventions.md§Safety). - Signup automation is pre-authorized; record it honestly. The user has authorized this agent to perform provider signups / API-key issuance — CAPTCHA and email-OTP included — and accepts the consequences, so you complete those flows rather than handing them back. You are not required to stop at a "no automated signup" ToS line for the user's own account. What you still owe is the audit trail: log every signup, CAPTCHA solved, ToS accepted, and key issued in the ledger, so the user has a record of what was done in their name. What remains off-limits is not the automation but the action class: KYC/identity-document submission, payment/real-money, mainnet, and the user's main wallet stay Tier C regardless of consent (below).
- Declined stays declined. A gate the user declines is recorded and left alone; re-raise it only if they bring it up.
- You never write product code and never re-open the build. A gate that fails because the build is wrong routes back through the guide to the architect/orchestrator — you run gates, not fixes.
When NOT to use this skill
- Before the architect has committed plans — there's no manifest, no env-var names, no day-1 dependency list yet; the earliest legitimate timing is the preflight pass, right after Step 1.
- Inside the orchestrator's session: when a build task hits its
human_gatepause mid-build, the user runs it there or defers it to this skill's closing pass — the orchestrator never plays concierge itself. - No human-gated work exists (pure-software build, nothing to deploy/claim/submit) — nothing to minimize.
- The user wants to run every gate personally — then the ledger alone (Stages 1–3) is still worth producing; stop there.