Quark Drive Console Session
The local web panel (pcui serve, shown as Quark Drive Console) and you collaborate through ONE
shared session store: the panel is the session's eyes and hands, you are the decision participant.
This skill adds exactly one thing to your normal workflow — session I/O through pcui. The
team-building discipline itself is unchanged: follow pokemon-champions-team's assisted workflow
(UEP) exactly as you always do.
CLI
The pcui command for this machine (works from any directory): {{PCUI_CMD}}
(bridge directory: {{BRIDGE_DIR}})
{{PCUI_CMD}} session show <S> # meta (intent, format, team) + heads + ledger
{{PCUI_CMD}} run <op> --session <S> [--file f.json] [--context ctx.json] [--args '<json>'] [--out out.json]
# run one team operator in the daemon AND
# submit its gate artifacts to the session
{{PCUI_CMD}} session wait <S> [--for decision|intake-answer] [--timeout 1800]
# block until the reader answers in the panel;
# prints that artifact (rc 3 on timeout)
{{PCUI_CMD}} artifact get --session <S> --kind <kind> # latest artifact of that kind (verbatim)
{{PCUI_CMD}} artifact put --session <S> --kind <kind> --revision <R> --file out.json
# for what no operator produces; R is the
# session revision read BEFORE doing the work
{{PCUI_CMD}} session create --intent "<request>" [--format double] [--kind build] [--team team.json]
{{PCUI_CMD}} open --no-browser [--session <S>] # a fresh one-time link to the panel
MCP instead of the CLI: when the quark-drive MCP tools are available ({{PCUI_CMD}} mcp;
{{PCUI_CMD}} mcp --print-config shows how the user registers it), use them — same daemon, same
semantics: session_list, session_show, session_create, artifact_get, artifact_put (pass the
revision you read; a conflict comes back as is, so re-read and decide), run_operator (with
session and output_path, exactly like run --session --out), session_wait (returns status: timeout to call again) and open_link. Everything below applies to both.
Typed deterministic tools also expose team_review, team_try, review_claims, slate_init,
team_fill, team_tune_cell, team_localize, team_counters, team_ko_scan, team_speed_ladder,
team_scenario and team_threshold. Use their schemas instead of guessing generic arguments.
File inputs are inline JSON, never local paths. output_path on review/try saves the full report
from that run; Console receives a display summary. Copy the saved full report into subsequent
claim/tuning inputs. Typed tools use the same daemon session and UEP gates as run_operator.
inference_prior and inference_init/add/status/remove/example/import_web/schema expose portable
calculator cases. Every call supplies the current case and returns new JSON; there is no hidden
case state, automatic team write or confirmed opponent set. Prior/observations are inline objects;
keep frozen source evidence and the calculator's uncertainty. These query tools do not append a
session gate. A surviving example is a hypothesis, not a recommendation or factual identification.
Canceling session_wait stops that wait. Canceling a run_operator reply does not retract work
already sent to the daemon: it may still complete and commit. Read session_show before retrying.
Always pass the exact session id on every command. session use is a shared, human-only CLI
convenience; another assistant or terminal can change it. Do not use it or rely on environment
variables persisting between agent shell calls. Give run an --out file whenever the
output may be large (frame, slate-evaluate, diagnose): stdout then carries a one-line summary that
lists the artifacts it submitted, and the file holds the FULL result body, directly consumable by
the next gate (without an {op, rc, result} envelope). A failed output-file save may follow a
successful gate commit: read the returned completion/artifact details before deciding to rerun.
Gate artifacts: run --session submits them
Run every UEP gate operator through run <op> --session <S>. The daemon then submits, in ledger order:
| op |
submitted kinds |
context-audit (with --context) |
context (the context it read), audit |
frame |
frame |
slate-evaluate |
slate — the panel gets the summary view; YOUR output stays full |
checkpoint |
checkpoint |
answer-audit (with --file draft.json) |
draft (the draft it read), answer-audit |
intake with "next": true |
intake (the batch the panel shows as a form) |
tune |
tune-result |
diagnose (with --file team.json) |
team (the team it read), diagnose — the panel shows the report |
review / diagnose --focus |
review display summary; preserve full result for evidence |
try |
trial display summary; original team stays unchanged |
review-claims |
review-claims recomputation result |
slate-init |
slate-input candidate transport; does not certify delivery |
A consecutive rerun of the same gate adds nothing. An intervening draft, answer or other gate makes
it a new ledger application even when the result bytes match. Use artifact put only for content no operator
produced. Everything you submit is shown live; the panel also shows which operator is running.
Workflow
- Find the session: a Console handoff names an exact session id — use that id, not the newest,
and include it explicitly on every call.
session show <S> gives meta.intent (the request typed in the
panel), heads (latest artifact per kind) and the ledger. New requests may include meta.format,
meta.requestKind, meta.team (the canonical attached team snapshot), meta.teamName and
meta.environment. Read these before intake; use the attached builds for rework/diagnosis/tuning,
preserving their completeness and the user's constraints. Old intent-only sessions remain valid.
The task kind is a hint, not permission to skip the normal UEP gates or silently change the team.
- Read what exists:
artifact get every kind in heads that matters — context, decision
(the reader's checkpoint answer: chooseCandidate + candidateIndex into your slate's teams,
requestChanges + note, or proceed) and intake-answer (below). A handoff that says the reader
decided or answered in the panel means: read that artifact first and continue from it. A handoff
that says review failed means: read answer-audit, fix what it names, and run answer-audit again.
- Work the UEP flow normally (context-audit → grounding → frame → assemble → slate-evaluate →
checkpoint → answer-audit), with each gate operator run as
run <op> --session <S>. Batch related
lookups (ranking/landscape/repset/validate) into one session spec instead of many shell-outs;
fall back to a raw team.py only when the daemon is down, then artifact put the gate outputs.
- Ask through the panel when the user is there: run
intake --next as
run intake --session <S> --args '{"next": true, "format": "<f>", "answered": [...]}' --context ctx.json,
say in one line that the questions are on the panel, then session wait <S> --for intake-answer.
The reader may still answer in conversation instead; either is a user answer. An intake-answer
is {answers: [{id, option?, text?, skipped?}], note?}: apply each chosen option's maps_to
exactly as for a numbered reply, echo a typed text back before committing it, and add every
answered id to --answered for the next batch.
- Checkpoint pause: when the checkpoint output says
pause:true (and the context did not
encode direct_final/skip_checkpoint), tell the user to decide in the panel (give the
open --no-browser --session <S> link if they may not have it open), then
session wait <S> --for decision. Hosts that can run a command in the background (Claude Code) should
do so and continue when it completes; otherwise run it in the foreground. On a timeout (rc 3), stop
the turn; next time, read decision first and continue from it.
- Draft prose: narrate in the USER'S language, but name every ENTITY by English
canonical. In
tradeoffs, assumptions[].note, confidence_notes,
convergence_rationale, context_summary: species, moves, items and abilities are
written EXACTLY as they appear in operator output ("Whimsicott", "Last Respects") —
never hand-translated. The panel localizes canonical names with dex authority at render time.
- Artifact size: the daemon rejects a body over ~2 MiB on
artifact put. Only slate risks that,
and run slate-evaluate --session <S> already submits the summary view. Keep the FULL slate output for
your own reasoning and for answer-audit (its claim recompute re-hashes the untrimmed
matchup_risk) — pass the full output file as answer-audit's slate_output.
- Tuning: SP adjustment intent becomes
build-context.benchmarks[] and run tune --session <S> --context ctx.json --file team.json per the team skill; the panel renders its cards. Sessions from
older panels may carry a tune-request ({note, member?, member_set?, team?, form_benchmarks?});
translate its note the same way and keep any form_benchmarks the user already ran.
- Conflicts: a gate commits all its artifacts against the revision it read before running.
A 409 means the inputs are stale or another run is active: re-read the session and reader's
answers, decide what is still applicable, then rerun. Never blindly repeat an old write.
Both MCP
artifact_put and CLI artifact put --revision <R> require the revision read before
doing the work. On conflict, review the newer artifacts and revise your output as needed;
do not merely fetch a newer revision and retry the old output. The CLI never chooses a baseline.
When the user started in conversation rather than the panel and wants to follow along there, create
the session yourself (session create --intent … [--team team.json]), keep its id explicit, and hand the
user the open --no-browser --session <S> link.
1---2name: pokemon-champions-ui-session-23description: Work on a Quark Drive Console (local Pokémon Champions UI) session — read its request, format, attached team and artifacts through the pcui CLI, run the normal UEP team-building flow with each gate's artifact submitted as it runs, and wait for the reader's answers in the panel so the local web page shows progress live. Trigger when the user asks to handle a Quark Drive local session (including an exact session id), continue one after deciding or answering in the panel, or wants their work shown in the local Console. Chinese examples include "处理 Quark Drive 本地会话 <id>", "继续处理会话 <id>", "处理当前 Pokémon UI 会话", "看看 UI 会话的决策". English examples include "work on Quark Drive local session <id>", "continue session <id>", "work on the current Pokémon UI session". Japanese examples include "Quark Driveのローカルセッション <id> を処理して", "セッション <id> を続けて". Requires the pokemon-champions-team skill (and its sibling data skills) — this skill only adds the session I/O, never replaces the UEP discipline.4metadata:5 source: https://skillmd.com/skills/pmwl0128/pokemon-champions-ui-session-26---78# Quark Drive Console Session910The local web panel (`pcui serve`, shown as Quark Drive Console) and you collaborate through ONE11shared session store: the panel is the session's eyes and hands, you are the decision participant.12This skill adds exactly one thing to your normal workflow — session I/O through `pcui`. The13team-building discipline itself is unchanged: follow `pokemon-champions-team`'s assisted workflow14(UEP) exactly as you always do.1516## CLI1718The pcui command for this machine (works from any directory): `{{PCUI_CMD}}`19(bridge directory: `{{BRIDGE_DIR}}`)2021```22{{PCUI_CMD}} session show <S> # meta (intent, format, team) + heads + ledger23{{PCUI_CMD}} run <op> --session <S> [--file f.json] [--context ctx.json] [--args '<json>'] [--out out.json]24 # run one team operator in the daemon AND25 # submit its gate artifacts to the session26{{PCUI_CMD}} session wait <S> [--for decision|intake-answer] [--timeout 1800]27 # block until the reader answers in the panel;28 # prints that artifact (rc 3 on timeout)29{{PCUI_CMD}} artifact get --session <S> --kind <kind> # latest artifact of that kind (verbatim)30{{PCUI_CMD}} artifact put --session <S> --kind <kind> --revision <R> --file out.json31 # for what no operator produces; R is the32 # session revision read BEFORE doing the work33{{PCUI_CMD}} session create --intent "<request>" [--format double] [--kind build] [--team team.json]34{{PCUI_CMD}} open --no-browser [--session <S>] # a fresh one-time link to the panel35```3637**MCP instead of the CLI**: when the `quark-drive` MCP tools are available (`{{PCUI_CMD}} mcp`;38`{{PCUI_CMD}} mcp --print-config` shows how the user registers it), use them — same daemon, same39semantics: `session_list`, `session_show`, `session_create`, `artifact_get`, `artifact_put` (pass the40`revision` you read; a conflict comes back as is, so re-read and decide), `run_operator` (with41`session` and `output_path`, exactly like `run --session --out`), `session_wait` (returns `status:42timeout` to call again) and `open_link`. Everything below applies to both.4344Typed deterministic tools also expose `team_review`, `team_try`, `review_claims`, `slate_init`,45`team_fill`, `team_tune_cell`, `team_localize`, `team_counters`, `team_ko_scan`, `team_speed_ladder`,46`team_scenario` and `team_threshold`. Use their schemas instead of guessing generic arguments.47File inputs are inline JSON, never local paths. `output_path` on review/try saves the full report48from that run; Console receives a display summary. Copy the saved full report into subsequent49claim/tuning inputs. Typed tools use the same daemon session and UEP gates as `run_operator`.5051`inference_prior` and `inference_init/add/status/remove/example/import_web/schema` expose portable52calculator cases. Every call supplies the current case and returns new JSON; there is no hidden53case state, automatic team write or confirmed opponent set. Prior/observations are inline objects;54keep frozen source evidence and the calculator's uncertainty. These query tools do not append a55session gate. A surviving example is a hypothesis, not a recommendation or factual identification.5657Canceling `session_wait` stops that wait. Canceling a `run_operator` reply does not retract work58already sent to the daemon: it may still complete and commit. Read `session_show` before retrying.5960**Always pass the exact session id on every command.** `session use` is a shared, human-only CLI61convenience; another assistant or terminal can change it. Do not use it or rely on environment62variables persisting between agent shell calls. Give `run` an `--out` file whenever the63output may be large (frame, slate-evaluate, diagnose): stdout then carries a one-line summary that64lists the artifacts it submitted, and the file holds the FULL result body, directly consumable by65the next gate (without an `{op, rc, result}` envelope). A failed output-file save may follow a66successful gate commit: read the returned completion/artifact details before deciding to rerun.6768## Gate artifacts: `run --session` submits them6970Run every UEP gate operator through `run <op> --session <S>`. The daemon then submits, in ledger order:7172| op | submitted kinds |73|---|---|74| `context-audit` (with `--context`) | `context` (the context it read), `audit` |75| `frame` | `frame` |76| `slate-evaluate` | `slate` — the panel gets the summary view; YOUR output stays full |77| `checkpoint` | `checkpoint` |78| `answer-audit` (with `--file draft.json`) | `draft` (the draft it read), `answer-audit` |79| `intake` with `"next": true` | `intake` (the batch the panel shows as a form) |80| `tune` | `tune-result` |81| `diagnose` (with `--file team.json`) | `team` (the team it read), `diagnose` — the panel shows the report |82| `review` / `diagnose --focus` | `review` display summary; preserve full result for evidence |83| `try` | `trial` display summary; original team stays unchanged |84| `review-claims` | `review-claims` recomputation result |85| `slate-init` | `slate-input` candidate transport; does not certify delivery |8687A consecutive rerun of the same gate adds nothing. An intervening draft, answer or other gate makes88it a new ledger application even when the result bytes match. Use `artifact put` only for content no operator89produced. Everything you submit is shown live; the panel also shows which operator is running.9091## Workflow92931. **Find the session**: a Console handoff names an exact session id — use that id, not the newest,94 and include it explicitly on every call. `session show <S>` gives `meta.intent` (the request typed in the95 panel), `heads` (latest artifact per kind) and the ledger. New requests may include `meta.format`,96 `meta.requestKind`, `meta.team` (the canonical attached team snapshot), `meta.teamName` and97 `meta.environment`. Read these before intake; use the attached builds for rework/diagnosis/tuning,98 preserving their completeness and the user's constraints. Old intent-only sessions remain valid.99 The task kind is a hint, not permission to skip the normal UEP gates or silently change the team.1002. **Read what exists**: `artifact get` every kind in `heads` that matters — `context`, `decision`101 (the reader's checkpoint answer: `chooseCandidate` + `candidateIndex` into your slate's teams,102 `requestChanges` + note, or `proceed`) and `intake-answer` (below). A handoff that says the reader103 decided or answered in the panel means: read that artifact first and continue from it. A handoff104 that says review failed means: read `answer-audit`, fix what it names, and run answer-audit again.1053. **Work the UEP flow normally** (context-audit → grounding → frame → assemble → slate-evaluate →106 checkpoint → answer-audit), with each gate operator run as `run <op> --session <S>`. Batch related107 lookups (ranking/landscape/repset/validate) into one `session` spec instead of many shell-outs;108 fall back to a raw `team.py` only when the daemon is down, then `artifact put` the gate outputs.1094. **Ask through the panel when the user is there**: run `intake --next` as110 `run intake --session <S> --args '{"next": true, "format": "<f>", "answered": [...]}' --context ctx.json`,111 say in one line that the questions are on the panel, then `session wait <S> --for intake-answer`.112 The reader may still answer in conversation instead; either is a user answer. An `intake-answer`113 is `{answers: [{id, option?, text?, skipped?}], note?}`: apply each chosen option's `maps_to`114 exactly as for a numbered reply, echo a typed `text` back before committing it, and add every115 answered id to `--answered` for the next batch.1165. **Checkpoint pause**: when the checkpoint output says `pause:true` (and the context did not117 encode `direct_final`/`skip_checkpoint`), tell the user to decide in the panel (give the118 `open --no-browser --session <S>` link if they may not have it open), then119 `session wait <S> --for decision`. Hosts that can run a command in the background (Claude Code) should120 do so and continue when it completes; otherwise run it in the foreground. On a timeout (rc 3), stop121 the turn; next time, read `decision` first and continue from it.1226. **Draft prose: narrate in the USER'S language, but name every ENTITY by English123 canonical.** In `tradeoffs`, `assumptions[].note`, `confidence_notes`,124 `convergence_rationale`, `context_summary`: species, moves, items and abilities are125 written EXACTLY as they appear in operator output ("Whimsicott", "Last Respects") —126 never hand-translated. The panel localizes canonical names with dex authority at render time.1277. **Artifact size**: the daemon rejects a body over ~2 MiB on `artifact put`. Only `slate` risks that,128 and `run slate-evaluate --session <S>` already submits the summary view. Keep the FULL slate output for129 your own reasoning and for `answer-audit` (its claim recompute re-hashes the untrimmed130 `matchup_risk`) — pass the full output file as answer-audit's `slate_output`.1318. **Tuning**: SP adjustment intent becomes `build-context.benchmarks[]` and `run tune --session <S>132 --context ctx.json --file team.json` per the team skill; the panel renders its cards. Sessions from133 older panels may carry a `tune-request` (`{note, member?, member_set?, team?, form_benchmarks?}`);134 translate its note the same way and keep any `form_benchmarks` the user already ran.1359. **Conflicts**: a gate commits all its artifacts against the revision it read before running.136 A 409 means the inputs are stale or another run is active: re-read the session and reader's137 answers, decide what is still applicable, then rerun. Never blindly repeat an old write.138 Both MCP `artifact_put` and CLI `artifact put --revision <R>` require the revision read before139 doing the work. On conflict, review the newer artifacts and revise your output as needed;140 do not merely fetch a newer revision and retry the old output. The CLI never chooses a baseline.141142When the user started in conversation rather than the panel and wants to follow along there, create143the session yourself (`session create --intent … [--team team.json]`), keep its id explicit, and hand the144user the `open --no-browser --session <S>` link.