task-pipeline-skill 1.89.1 → 1.90.0

package/CHANGELOG.md

@@ -1,3 +1,48 @@
+## v1.90.0 — Code Connect is kept, and token names are measured against the file
+
+The build stage already said a component with a Code Connect mapping is used, never
+rewritten. Nothing said the mapping had to stay true. A mapping that still names a
+component's old props hands the next agent a snippet that does not compile, and the agent
+reimplements the component, which is the fork the rule exists to prevent. Token names had
+the same gap: rule 4 made `get_variable_defs` the canon, and no check compared it with the
+code. A variable that is `color/primary` in the file and `--brand-primary` in CSS split in
+two without anything noticing. The scope comes from a 2026-10-08 reading of Figma's own
+guidance ([Code Connect integration][fcc-cl], [Figma MCP use cases][fuc-cl], both accessed
+2026-10-08).
+
+Guards: 430 → **430**. The new check is a verb of a shipped script with a suite of its
+own, and the validator is unchanged.
+
+- **`references/build.md` → *Code Connect, kept*.** A component whose API changes updates
+  its Code Connect mapping in the same change, quoting Figma's own line. A core component
+  the file draws and nothing maps gets an **offer** to map it with `/figma-code-connect`,
+  Figma's public plugin skill. Mapping publishes to the file, so it runs only on a go. The
+  rule against rewriting a mapped component stands unchanged. Figma's measured benefit is
+  quoted as **Figma's unaudited number**: a vendor's eval of its own feature, not
+  reproduced here.
+- **`visual_gate.py tokens --figma <variables.json> --css <tokens.css>`, the token drift
+  probe.** It reads the `get_variable_defs` map, the REST export (`meta.variables`) or a
+  `variables` list, and the custom properties the pack's token file declares (comments
+  stripped, `var()` uses not counted). It names each variable with no property, each
+  property with no variable, each variable whose WEB code syntax is not the property the
+  file declares, and two variables that land on one property. Exit `0` PASS · `1` FAIL ·
+  `2` unreadable · `3` NOT_RUN. No export, or an export holding no variables, is NOT_RUN
+  and never PASS. A nested token tree is refused as unreadable, so the check never
+  compares the code with group names.
+- **Wired in** to `references/browser.md` → *The visual half* (the deterministic floor),
+  `references/stages.md` stage 5 (after a task that touches tokens, beside the project
+  linter) and stage 6 (over the whole token file, inside the contact-sheet check). It is
+  also a row in `companion-skills.md` → *Visual lanes* for `figma-code-connect`.
+- **Routing words.** The description now carries `bug` as its own word next to `fix`, so
+  "fix this bug" is claimed by name and not through `bug hunt`. 903 → 908 of 1024 chars,
+  inside the 970 working limit. The body is unchanged at 4748/4750 tokens.
+- **Tests:** `test/visual_gate_test.py` 24 → **40** cases. The 16 new ones are planted
+  defects, and all 16 were watched failing before `tokens` existed. A sweep of 15
+  mutations of the new code was run, and every mutation was killed.
+
+[fcc-cl]: https://developers.figma.com/docs/figma-mcp-server/code-connect-integration/
+[fuc-cl]: https://www.figma.com/resource-library/figma-mcp-use-cases/
+
 ## v1.89.1 — v1.89.0's payload, released with its no-stamp declaration
 
 `v1.89.0` was refused by its own release check: the release carried no run stamp and was not

package/README.md

@@ -587,7 +587,7 @@ must say so.
 ### Held to Anthropic's own Skill authoring guidance
 
 Audited against the four Agent Skills pages. Most of it already held — `name`
-13/64 chars, `description` 903/1024 chars, `SKILL.md` 279/500 lines, all 39 references
+13/64 chars, `description` 908/1024 chars, `SKILL.md` 279/500 lines, all 39 references
 linked **directly** from `SKILL.md`, and the bundle far under the 30 MB ceiling. What
 did not, now does:
 

package/SKILL-CARD.md

@@ -12,7 +12,7 @@ harmless.
 |---|---|
 | **Purpose** | Runs a substantial task through ten gated delivery stages — intake grill, docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs+registers, acceptance — refusing to advance until each gate passes |
 | **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
-| **Version** | 1.89.1 |
+| **Version** | 1.90.0 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. Every stage's doctrine ships in-repo; the one conditional requirement is super-ux for the stage-3 UX track on a user-facing task |
 | **Evaluation status** | Suite authored, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.89.1",
+  "version": "1.90.0",
   "description": "Full-cycle delivery pipeline for coding agents: a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine ships inside the skill — no companion plugin required. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "task-pipeline",
   "displayName": "Task Pipeline",
   "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a loop guard whose review ceiling measures rather than stops, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs). Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.89.1",
+  "version": "1.90.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/skills/task-pipeline/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: task-pipeline
-description: "Use when work changes the repository — feature, fix, refactor, migration, integration, rewrite, adoption or hardening; фича, фикс, рефактор, миграция, интеграция, доработать, починить, внедрить, перевести — or when the output is a finding that lands in it: audit/аудит, bug hunt/проверь ошибки, production check/проверь прод, PR review/ревью PR — or on 'run this through the pipeline' / 'прогони по конвейеру', 'full cycle, the full cycle' / 'полный цикл', /task-pipeline. Runs a substantial task through an intake grill, docs study, brainstorm, spec, plan, build, tests, deploy, post-deploy, docs/wiki sync and acceptance with explicit gates. 'checkup' / 'чекап' reports unconfirmed releases; 'setup' audits existing docs. Not for: answering a question, explaining code, a typo or a one-line edit, a mechanical rename, reconnaissance that lands nothing — say 'no pipeline' / 'без пайплайна' to opt out."
+description: "Use when work changes the repository — feature, fix, bug, refactor, migration, integration, rewrite, adoption or hardening; фича, фикс, рефактор, миграция, интеграция, доработать, починить, внедрить, перевести — or when the output is a finding that lands in it: audit/аудит, bug hunt/проверь ошибки, production check/проверь прод, PR review/ревью PR — or on 'run this through the pipeline' / 'прогони по конвейеру', 'full cycle, the full cycle' / 'полный цикл', /task-pipeline. Runs a substantial task through an intake grill, docs study, brainstorm, spec, plan, build, tests, deploy, post-deploy, docs/wiki sync and acceptance with explicit gates. 'checkup' / 'чекап' reports unconfirmed releases; 'setup' audits existing docs. Not for: answering a question, explaining code, a typo or a one-line edit, a mechanical rename, reconnaissance that lands nothing — say 'no pipeline' / 'без пайплайна' to opt out."
 license: MIT
 compatibility: "Doctrine runs on any agent. The bundled scripts need python3; the run needs git. Missing either degrades, never blocks — the graph verbs and seeded gates go unused, and the run says so."
 ---

package/plugins/task-pipeline/skills/task-pipeline/references/browser.md

@@ -187,7 +187,17 @@ the close-out — the same rule as every other refusal in the pipeline.
 1. **Deterministic.** The project linter — `python3 scripts/visual_gate.py lint <dir>`,
    which runs sheleg-design's `--lint` where it is installed and answers **NOT_RUN (exit 3)**
    where it is not — plus axe or Lighthouse, the token check, the type checker. An S1
-   finding blocks, whatever anyone says about the picture later.
+   finding blocks, whatever anyone says about the picture later. **With Figma on, the
+   token check includes the drift probe**: `python3 scripts/visual_gate.py tokens
+   --figma <variables.json> --css <tokens.css>` compares the variable names exported
+   from the file (the JSON `get_variable_defs` returns, or the REST export) with the
+   custom properties the pack's token file declares. It names each variable with no
+   property, each property with no variable, and each variable whose WEB code syntax
+   is not the property the file actually declares. A name maps by kebab-case
+   (`Color/Text Muted` → `--color-text-muted`) unless code syntax says otherwise.
+   Exit `0` PASS · `1` FAIL · `2` unreadable · `3` NOT_RUN. No export is NOT_RUN,
+   never PASS: save the export beside the frames and run again, or record the probe
+   as not run.
 2. **Regression** against the approved baseline, where one exists (`toHaveScreenshot`, or
    the platform's snapshot test).
 3. **The matrix.** One frame per `SCR-NN` state the screen map lists (default, loading,

package/plugins/task-pipeline/skills/task-pipeline/references/build.md

@@ -532,10 +532,13 @@ it invents what was already decided.
    approximately, and approximate is indistinguishable from exact in a report.
 3. **A component with a Code Connect mapping is not rewritten.** If
    `get_code_connect_map` names a code component for that node, the screen uses it.
-   Reimplementing it is a silent fork of the design system.
+   Reimplementing it is a silent fork of the design system. *Code Connect, kept*, below,
+   is what keeps that mapping true.
 4. **A token names its variable.** A raw hex or px where the file has a variable is a
    token that has quietly split in two. `get_variable_defs` is the canon; a screenshot
-   is a way to *look*, never a way to *know*.
+   is a way to *look*, never a way to *know*. Whether the names still agree is
+   measured, not assumed: `visual_gate.py tokens` ([`browser.md`](browser.md) →
+   *The visual half*).
 5. **The frame is a contract at its own width.** It is one width and said nothing about
    the others, so behaviour at other breakpoints — and states the frame does not draw,
    like error, empty and loading — is a **decision that gets recorded**, not guessed.
@@ -559,6 +562,42 @@ same false confidence as an unproven green.
 platform constraint, an accessibility floor, a breakpoint — write what and why.
 Otherwise *"built from the frame"* and *"built to look like it"* read identically.
 
+### Code Connect, kept
+
+Rule 3 trusts the mapping. It is only worth trusting while it stays true. A mapping
+that still names a component's old props hands the next agent a snippet that does
+not compile, so it is followed by reimplementing the component. That is the fork
+rule 3 exists to prevent, reached by obeying it.
+
+- **A component whose API changes updates its Code Connect mapping in the same
+  change.** That covers a renamed or removed prop, a new variant, or a moved import
+  path. The mapping file is part of the component's diff and reviewed with it. A
+  mapping left for later is wrong from the next merge onwards. Figma's own guidance
+  says the same: *"When component APIs change in your codebase, update the
+  corresponding Code Connect mappings"* ([Code Connect integration][fcc], accessed
+  2026-10-08).
+- **A core component with no mapping gets an offer, not a silent skip.** Where a
+  task builds on a design-system component that the file draws and Code Connect does
+  not map, the run offers to map it with `/figma-code-connect`, Figma's public
+  plugin skill ([`companion-skills.md`](companion-skills.md)). The offer names which
+  components and which file. Mapping publishes to the Figma file, so it runs only on
+  an explicit go, like drawing a missing frame. Absent the skill, the run names the
+  unmapped components in the close-out and goes on.
+- **Never rewrite a mapped component instead of using it** — rule 3, unchanged. An
+  API that no longer fits the frame is a change to the component and its mapping
+  together, never a local copy.
+
+Why it pays, in Figma's words and on Figma's measurement: their own evals report *"a
+19.6% reduction in median task duration, a full point of improvement in code quality
+on a 1–4 scale, and a 29.5% reduction in token usage"* with Code Connect
+([Figma MCP use cases][fuc], accessed 2026-10-08). **That is Figma's unaudited
+number** — a vendor's eval of its own feature, with no published protocol here and
+not reproduced by this pipeline. Quote it as theirs, never as a measured property
+of a run.
+
+[fcc]: https://developers.figma.com/docs/figma-mcp-server/code-connect-integration/
+[fuc]: https://www.figma.com/resource-library/figma-mcp-use-cases/
+
 ## 5. Final whole-branch review
 
 After the last task: build a package over `MERGE_BASE`..`HEAD`

package/plugins/task-pipeline/skills/task-pipeline/references/companion-skills.md

@@ -100,6 +100,7 @@ required; an absent one is a check recorded as NOT_RUN with its reason.
 | Compose `enableAccessibilityChecks` | Android's accessibility checks in Compose UI tests | stage 6, a native Android surface |
 | Playwright `toHaveScreenshot` | screenshot regression against the approved baseline, per state and theme | stage 6 (regression), and the nightly or release baseline after |
 | axe-core | the deterministic accessibility floor of a web surface | stage 6, first in the cheap-first order |
+| `figma-code-connect` (Figma's public plugin skill) | maps a design-system component in the file to its code component, so `get_design_context` hands the agent the real import instead of approximated markup | stage 5, **offered** for a core component the file draws and nothing maps — publishes to the file, so it needs a go ([`build.md`](build.md) → *Code Connect, kept*) |
 
 A native screen is captured on a simulator or a device; a web render styled as a phone is
 a mockup, and the native rows of the sheet stay NOT_RUN without one.

package/plugins/task-pipeline/skills/task-pipeline/references/stages.md

@@ -473,7 +473,13 @@ never that the work was skipped quietly.
   `surface_class`, the project linter runs here too**, after each task that changes a
   rendered surface — `python3 scripts/visual_gate.py lint <dir>`; an S1 finding is
   fixed in the task, and NOT_RUN (exit 3) is recorded as such
-  ([`browser.md`](browser.md) → *The visual half*). A slop marker caught while the
+  ([`browser.md`](browser.md) → *The visual half*). **With Figma on, the token drift
+  probe runs beside it** after a task that touches the token file or a tokenised
+  component: `python3 scripts/visual_gate.py tokens --figma <variables.json> --css
+  <tokens.css>`. A FAIL is fixed in the task, renaming one side to match the other.
+  No export is NOT_RUN, recorded as such. A component whose API the task changed
+  updates its Code Connect mapping in the same change
+  ([`build.md`](build.md) → *Code Connect, kept*). A slop marker caught while the
   implementer is dispatched costs a line; caught on the contact sheet it costs a round. Stage 6 repeats this over the whole tree; this one catches it while the
   implementer that wrote it is still dispatched. The matrix pointed this companion at
   stages 5–6 from the day it was added and **this stage had never named it** — found by
@@ -550,7 +556,9 @@ never that the work was skipped quietly.
   `ad` surface, stage 6 also owes **the contact sheet** — frames over the `SCR-NN` states
   × viewport × theme × text × locale (pairwise, plus the mandatory pairs), each with its
   capture record, diffed against its Figma frame or approved baseline, the project
-  linter run, and the rubric read by a judge that is not the builder — and its command
+  linter run, the token drift probe run over the whole token file where Figma is on
+  (`visual_gate.py tokens`; NOT_RUN without an export, never PASS), and the rubric
+  read by a judge that is not the builder — and its command
   exits 0: `python3 scripts/visual_gate.py sheet <contact-sheet.json> --class
   <surface_class> --artifact-root <frames>` (NOT_RUN, exit 3, is not green). On
   `internal` it is recommended and the linter is the floor. The re-render budget is

package/plugins/task-pipeline/skills/task-pipeline/scripts/visual_gate.py

@@ -15,6 +15,11 @@
     visual_gate.py filekeys --record <foundation.md or brief> --screens <screens.md> [--json]
         stage 3 with Figma on: every frame link's file key is one of the files the project
         recorded — one per surface (App, Web, ASO), never a file nobody recorded
+    visual_gate.py tokens   --figma <variables.json> --css <tokens.css> [--json]
+        stages 5–6 with Figma on, the token drift probe: every variable name exported from
+        the file (`get_variable_defs`, or the REST export) has its CSS custom property in
+        the pack's token file and the reverse, and WEB code syntax, where set, names the
+        property the file actually declares. No export is NOT_RUN (exit 3), never PASS
 
 `<surface_class>` is the brief's stage-0 answer: flagship | product | internal | ad. It
 selects what each check owes (`references/stages.md` → stage 0, *The surface class*).
@@ -536,6 +541,134 @@ def cmd_filekeys(a):
     return _emit(a, "filekeys", "FAIL" if problems else "PASS", problems, notes)
 
 
+# --- token-name drift: Figma variables against the pack's CSS custom properties ---
+# A token that has one name in the file and another in code has quietly split in two, and
+# nothing downstream notices: `get_design_context` hands the agent the Figma name, the agent
+# writes a raw value because no property answers to it, and the screen still looks right.
+
+CSS_DECL = re.compile(r"(?<![\w-])(--[A-Za-z0-9_-]+)\s*:")
+CS_PROP = re.compile(r"\s*(?:var\(\s*)?(--[A-Za-z0-9_-]+)\s*(?:,[^)]*)?\)?\s*")
+# Keys a variable's own record can carry. A dict value with none of them is a token GROUP
+# (a nested design-token tree), not a variable, and reading its key as a name would compare
+# the code against the group names.
+VAR_KEYS = ("codeSyntax", "value", "$value", "resolvedType", "type", "valuesByMode")
+
+
+def css_property(name):
+    """The CSS custom property a Figma variable name maps to when it carries no code syntax:
+    `Color/Text Muted` → `--color-text-muted`, `fontSize/bodyLarge` → `--font-size-body-large`.
+    A convention, not a law — WEB code syntax, where the file sets it, overrides it."""
+    s = re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", name)
+    return "--" + re.sub(r"[^A-Za-z0-9]+", "-", s).strip("-").lower()
+
+
+def figma_variables(doc):
+    """[(name, web_code_syntax or None)] from a variable export. Accepts the map
+    `get_variable_defs` returns (name → value), the REST export (`meta.variables`, id →
+    variable) and a `variables` list. Raises ValueError on any other shape."""
+    if isinstance(doc, dict) and isinstance(doc.get("meta"), dict) and "variables" in doc["meta"]:
+        doc = doc["meta"]["variables"]
+    elif isinstance(doc, dict) and isinstance(doc.get("variables"), (list, dict)):
+        doc = doc["variables"]
+
+    def one(v):
+        cs = v.get("codeSyntax")
+        return v["name"], (cs.get("WEB") if isinstance(cs, dict) else None)
+
+    if isinstance(doc, list):
+        if not all(isinstance(v, dict) and isinstance(v.get("name"), str) for v in doc):
+            raise ValueError("a `variables` list whose items are not {name, …} objects")
+        return [one(v) for v in doc]
+    if not isinstance(doc, dict):
+        raise ValueError(f"a {type(doc).__name__}, not a variable map")
+    if doc and all(isinstance(v, dict) and isinstance(v.get("name"), str) for v in doc.values()):
+        return [one(v) for v in doc.values()]
+    out = []
+    for k, v in doc.items():
+        if isinstance(v, dict):
+            if not any(key in v for key in VAR_KEYS):
+                raise ValueError(f"{k!r} holds a group, not a variable — a nested token tree")
+            cs = v.get("codeSyntax")
+            out.append((k, cs.get("WEB") if isinstance(cs, dict) else None))
+        elif isinstance(v, list):
+            raise ValueError(f"{k!r} holds a list, not a variable's value")
+        else:
+            out.append((k, None))
+    return out
+
+
+def css_properties(text):
+    """Every custom property the token file DECLARES. Comments are stripped first, and a
+    `var(--x)` use is not a declaration."""
+    return set(CSS_DECL.findall(re.sub(r"/\*.*?\*/", "", text, flags=re.S)))
+
+
+def token_drift(variables, props):
+    """(problems, report) — names in one side and not the other, and code syntax that
+    disagrees with the property the token file actually has."""
+    problems, figma_only, syntax, used, owner = [], [], [], set(), {}
+    for name, cs in variables:
+        derived = css_property(name)
+        target = derived
+        if cs is not None:
+            m = CS_PROP.fullmatch(cs)
+            if not m:
+                syntax.append(f"{name}: WEB code syntax {cs!r} is not a CSS custom property")
+                continue
+            target = m.group(1)
+        if target in owner:
+            problems.append(f"{owner[target]!r} and {name!r} both map to {target} — one "
+                            "property cannot hold both")
+            continue
+        owner[target] = name
+        if target in props:
+            used.add(target)
+        elif cs is not None and derived in props:
+            used.add(derived)
+            syntax.append(f"{name}: code syntax names {target}, and the token file calls it "
+                          f"{derived}")
+        else:
+            figma_only.append(f"{name} → {target}")
+    css_only = sorted(props - used)
+    problems += [f"in Figma, not in the token file: {x}" for x in figma_only]
+    problems += [f"in the token file, not in Figma: {x}" for x in css_only]
+    problems += [f"code syntax: {x}" for x in syntax]
+    return problems, {"figma_only": figma_only, "css_only": css_only, "code_syntax": syntax,
+                      "matched": len(used)}
+
+
+def cmd_tokens(a):
+    try:
+        css = open(a.css, encoding="utf-8").read()
+    except OSError as e:
+        print(f"visual_gate: cannot read the token file {a.css} ({type(e).__name__})",
+              file=sys.stderr)
+        return 2
+    if not os.path.isfile(a.figma):
+        return _emit(a, "tokens", "NOT_RUN", [], [
+            f"no Figma variable export at {a.figma} — export it (`get_variable_defs`, or the "
+            "REST variables endpoint) and run again; until then the drift is unmeasured"])
+    try:
+        doc = json.load(open(a.figma, encoding="utf-8"))
+    except (OSError, ValueError) as e:  # JSONDecodeError and UnicodeDecodeError included
+        print(f"visual_gate: cannot read {a.figma} ({type(e).__name__})", file=sys.stderr)
+        return 2
+    try:
+        variables = figma_variables(doc)
+    except ValueError as e:
+        print(f"visual_gate: {a.figma} is not a variable export — {e}", file=sys.stderr)
+        return 2
+    if not variables:
+        return _emit(a, "tokens", "NOT_RUN", [], [
+            f"{a.figma} holds no variables — there is nothing to compare, and nothing "
+            "compared is not a pass"])
+    props = css_properties(css)
+    problems, rep = token_drift(variables, props)
+    notes = [f"{len(variables)} Figma variable(s), {len(props)} CSS custom propert"
+             f"{'y' if len(props) == 1 else 'ies'}, {rep['matched']} matched"]
+    return _emit(a, "tokens", "FAIL" if problems else "PASS", problems, notes, extra=rep)
+
+
 EXIT = {"PASS": 0, "FAIL": 1, "NOT_RUN": 3}
 
 
@@ -580,9 +713,15 @@ def main(argv):
     f.add_argument("--record", required=True)
     f.add_argument("--screens", required=True)
     f.add_argument("--json", action="store_true")
+    t = sub.add_parser("tokens", help="stages 5–6: Figma variable names against the CSS "
+                                      "custom properties of the pack's token file")
+    t.add_argument("--figma", required=True,
+                   help="the variable export (get_variable_defs JSON, or the REST export)")
+    t.add_argument("--css", required=True, help="the pack's token file")
+    t.add_argument("--json", action="store_true")
     a = p.parse_args(argv)
     return {"record": cmd_record, "sheet": cmd_sheet, "lint": cmd_lint,
-            "filekeys": cmd_filekeys}[a.cmd](a)
+            "filekeys": cmd_filekeys, "tokens": cmd_tokens}[a.cmd](a)
 
 
 if __name__ == "__main__":