aiki-cli 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Changelog
+
+## Unreleased
+
+### Added
+- **Contextual intent preflight** — idea-refinement now starts with an S0 run brief: the analyst generates
+  3-4 context-specific questions, the TUI asks them before the main council work, and the answers are
+  persisted in `00b-run-brief.json` and included in downstream prompts.
+- **Idea report v3** — idea-refinement reports now emit an explicit BLUF recommendation
+  (`PROCEED`, `PROCEED_WITH_CONDITIONS`, `PIVOT`, `STOP`), conditions when needed, a best-effort
+  12-dimension scorecard, assumption audit table in HTML, deterministic debate narrative, anchored
+  validation plan with kill signals (`09b-action-plan.json`), open questions, red-team note, and a
+  call/provider receipt. The Markdown copy button includes the expanded brief.
+
+### Changed
+- Idea-refinement run estimate is now ~12 provider calls / ~4 Claude-Opus calls because S0 writes the
+  intent preflight and the judge seat also writes the validation plan. The default budget is now 13 so
+  a normal run still has room for one repair without skipping the validation plan.
+
+## 0.2.0 — 2026-07-06 — v2 product round
+
+### Added
+- **Council View + HTML export** — `aiki show <run> --html [--open]` renders a plain-language decision
+  brief (verdict, risks that held up, blind spots, recommended next steps; raw per-model analysis in a
+  collapsible section). Renderer-only; artifacts/schemas unchanged.
+- **Slash-command home screen** — the TUI opens on a command home: `/idea <text>`, `/review [--branch]`,
+  `/resume <id>`, `/sessions`, `/models`, `/config`, `/help`. Plain (non-slash) text still routes to the
+  idea flow, or is redirected if it's a general question / code paste. It's a fixed parser, not chat.
+- **Run from anywhere** — hybrid storage: runs live in the project's `.aiki/` when inside a git repo, else
+  in `~/.aiki/`. `$AIKI_HOME` overrides the global home.
+- **Sessions + resume** — global registry (`~/.aiki/sessions.jsonl`); `aiki sessions` lists runs across
+  locations; `aiki resume <id>` (or `/resume`) continues a killed/timed-out run by **replaying** every
+  completed provider call from disk, so only the failed stage onward spends a real call.
+- **Per-provider models** — `aiki models` (Gemini enumerates via `agy models`; Claude/Codex take any id).
+  Pin a model per provider in `.aiki/config.json` or global `~/.aiki/config.json`. No hardcoded versions.
+- **Richer intent clarify** — the misunderstanding guard now offers pick-one / combine-all / type-your-own,
+  and merges same-meaning readings more reliably (stopword-stripped content overlap; threshold unchanged).
+- **Run-cost preview** — `aiki run` prints a call estimate and confirms before spending (skip with `--yes`
+  or in a non-interactive shell).
+
+### Changed
+- Per-call timeout 180→300s and wall-clock deadline 10→20min (a real Opus judge exceeded both).
+- Config is now layered: global `~/.aiki/config.json` (base) + project `.aiki/config.json` (override);
+  `aiki config` shows the merged effective config.
+
+### Safety (unchanged)
+- Read-only orchestration, no credential handling, no API keys, no write/exec tools, no chat. aiki writes
+  only under `.aiki/` / `~/.aiki/`.
+
+## 0.1.0 — v1
+
+- Local multi-model orchestration binding installed AI CLIs into schema-validated workflows
+  (idea-refinement + code-review) with a pre-registered benchmark harness. Thesis proven (RESULTS.md):
+  cross-provider structured review caught every planted bug where the best single model missed ~1 in 4, at
+  equal precision, on a 10-case held-out set.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gaurav Palaspagar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,275 @@
+<p align="center">
+  <img src="docs/One.png" alt="aiki — a local model council" width="820">
+</p>
+
+<h1 align="center">aiki</h1>
+
+<p align="center"><em>A local <strong>model council</strong> for code review and idea stress-testing — driven by the AI CLIs you already have.</em></p>
+
+<p align="center">
+  <img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg">
+  <img alt="Node ≥ 20" src="https://img.shields.io/badge/node-%E2%89%A5%2020-brightgreen.svg">
+  <img alt="Local-first, no API keys" src="https://img.shields.io/badge/local--first-no%20API%20keys-informational.svg">
+  <img alt="Read-only orchestration" src="https://img.shields.io/badge/orchestration-read--only-success.svg">
+  <img alt="Tests" src="https://img.shields.io/badge/tests-261%20passing-success.svg">
+</p>
+
+---
+
+**aiki** runs the AI coding CLIs you already have installed and logged in (Claude Code, Codex, Antigravity/Gemini)
+as a **panel that can genuinely disagree** — they review independently, cross-examine each other, a judge
+adjudicates the disputes, and you get a clear decision brief.
+
+It does two jobs, well:
+
+- **Code review** — catch the bugs a single model misses.
+- **Idea stress-testing** — pressure-test a plan before you build it.
+
+aiki is **not** a general assistant. Trivia and chat are routed away, not answered — a council adds cost, not
+accuracy, when there's one right answer.
+
+**Jump to:** [Why](#why) · [Benchmark](#benchmark) · [Requirements](#requirements) · [Install](#install) · [Quickstart](#quickstart) · [The two workflows](#the-two-workflows) · [Example](#example-a-real-idea-run) · [Configuration](#configuration) · [Sessions & resume](#sessions--resume) · [Safety](#safety-model) · [Costs & limits](#costs--limits) · [How it works](#how-it-works)
+
+---
+
+## Why
+
+On a code review or an "is this idea sound?" call, a single model has one blind spot. Two or three *different*
+models — each analyzing independently, then cross-examining — catch what any one misses. aiki orchestrates
+that locally: **no API keys, no new subscriptions**. It uses the CLIs and logins you already pay for, so you
+stop copy-pasting between them by hand.
+
+<p align="center">
+  <img src="docs/Three.png" alt="One model's field of view lets bugs slip past; three overlapping fields catch them all" width="820">
+</p>
+
+## Benchmark
+
+On a **pre-registered, 10-case held-out** code-review benchmark (frozen before the run so it couldn't be
+tuned post-hoc — see [BENCHMARK.md](BENCHMARK.md) and [RESULTS.md](RESULTS.md)):
+
+> **The cross-provider council caught _every_ planted bug where the best single model missed ~1 in 4 — at
+> equal precision, zero false positives.**
+
+| Arm | What it is | Seeded-bug recall | Precision | Provider calls |
+|---|---|---|---|---|
+| **B** | best single model — structured, self-adversarial review | 77% (33/43) | 1.00 | 10 |
+| **D** | **cross-provider council** — Claude + Codex review, Gemini judges | **100% (43/43)** | **1.00** | 44 |
+
+**→ 1.30× the recall at identical precision** (0 false positives across 59 adjudicated unmatched findings).
+
+<details>
+<summary><strong>Per-case results (every case, no cherry-picking)</strong></summary>
+
+| Case | Seeded bugs | B (single) | D (council) |
+|---|---|---|---|
+| 01 payments | 4 | 4/4 | 4/4 |
+| 02 inventory | 4 | 4/4 | 4/4 |
+| 03 comments | 4 | **1/4** | 4/4 |
+| 04 search | 5 | **2/5** | 5/5 |
+| 05 notifications | 4 | **2/4** | 4/4 |
+| 06 profile | 4 | 4/4 | 4/4 |
+| 07 dashboard | 5 | **3/5** | 5/5 |
+| 08 upload | 4 | 4/4 | 4/4 |
+| 09 sessions | 4 | 4/4 | 4/4 |
+| 10 analytics | 5 | 5/5 | 5/5 |
+| **Total** | **43** | **33/43 (77%)** | **43/43 (100%)** |
+
+The single model's misses cluster on 4 cases (03/04/05/07); the council caught all of them.
+</details>
+
+**Reproduce it yourself:** `aiki bench code-review --arms B,D --set holdout --yes`
+
+**Honest caveats (in full).** The win is a **recall** win — precision was non-discriminating on this bug-dense
+set. It is **not** a claim of beating cheap self-consistency (that comparison is deferred, not evaluated).
+n = 10 cases, single run per arm — directional, not a p-value. Full method and every number in
+[RESULTS.md §7](RESULTS.md).
+
+## Requirements
+
+> ⚠️ **aiki drives your existing CLIs — it does not ship or host any model.** You must have the provider CLIs
+> **installed and already logged in.** aiki never sees, stores, or transmits your credentials.
+
+- **Node ≥ 20.** (Node 16/18 will crash at startup — this is a hard requirement.)
+- **macOS or Linux** (WSL2 works).
+- The provider CLIs on your `PATH`, **each already authenticated**:
+  | CLI | Command | Shown in aiki as |
+  |---|---|---|
+  | Claude Code | `claude` | Claude |
+  | Codex | `codex` | Codex |
+  | Antigravity | `agy` | Gemini |
+- **At least 2 of the 3** must be ready (a council needs a panel). Check anytime with `aiki doctor`.
+
+```bash
+aiki doctor          # lists each provider: version, ready/not, read-only mode
+```
+
+## Install
+
+```bash
+npm install -g aiki-cli
+```
+
+From source:
+
+```bash
+git clone https://github.com/kratos619/Aiki.git
+cd Aiki
+npm install
+npm run build
+npm link             # puts `aiki` on your PATH   (or run directly: node dist/cli/index.js)
+```
+
+## Quickstart
+
+```bash
+aiki                 # opens the interactive home screen
+```
+
+Type a command, or just describe an idea and press Enter:
+
+| Command | What it does |
+|---|---|
+| `/idea <text>` | stress-test an idea with the council |
+| `/review [--branch]` | review your working-tree changes (or this branch vs its base) |
+| `/resume <id>` | continue a killed/timed-out run — replays finished work, only redoes the rest |
+| `/sessions` | list past runs (newest first) |
+| `/models` | show / choose the model each provider uses |
+| `/config` | show the effective config |
+| `/help` | the command list |
+
+The command palette filters as you type (`/mo` → `/models`); **Tab** completes, **↑/↓** pick, **Enter** runs.
+Plain text is never charged silently — you get a confirm step before any run spends model calls.
+
+**Headless (scriptable):**
+
+```bash
+aiki run idea-refinement "a fridge-photo-to-recipe app for busy parents"
+aiki run idea-refinement ./idea.md
+aiki run code-review --base main             # review this branch vs main
+aiki run code-review --diff ./changes.patch  # review a patch file
+aiki run code-review --cheap                 # Gemini+Codex review, Claude judges only disputes (~⅓ the Opus)
+aiki show <run-id> --html --open             # open the shareable decision brief in your browser
+```
+
+An idea run **auto-opens** its report in your browser when it finishes.
+
+## The two workflows
+
+<p align="center">
+  <img src="docs/Four.png" alt="Three reviewers → cross-examination → a judge → a decision brief" width="820">
+</p>
+
+**Code review** — parallel blind review → deterministic file:line validation (every finding must point at a
+real line in the diff) → mutual adversarial cross-examination → consensus/dispute map → the judge adjudicates
+only the disputes → report.
+
+**Idea refinement** — a contextual preflight (a few sharp questions to pin down what you actually mean) →
+intent contract → misunderstanding guard → parallel adversarial analysis → disagreement map → verifier →
+judge → a validation planner. The report is a **decision brief**, not an essay:
+
+- a **BLUF recommendation** — `PROCEED` / `PROCEED WITH CONDITIONS` / `PIVOT` / `STOP`
+- the **chairman's reasoning** (what decided it, where the models split, whose side the judge took)
+- a **dimension scorecard** (which of 12 angles were examined, contested, or missed)
+- an **assumption audit** (held / failed / unverified, with confidence)
+- **the debate** (who argued what, who won)
+- an **anchored validation plan** — concrete next actions, each with an effort estimate and a *kill signal*
+- a **cost receipt** (calls per provider)
+
+## Example: a real idea run
+
+<p align="center">
+  <img src="docs/Two.png" alt="Three models deliberate and cross-examine; the judge reaches a verdict" width="760">
+</p>
+
+```bash
+aiki run idea-refinement "Users keep asking for more features, so we should add a plugin marketplace to boost retention."
+```
+
+The council's verdict on that one:
+
+> **Recommendation: STOP.** The premise (churn is caused by missing features) is unproven; a marketplace adds
+> a security-vs-capability dilemma and a developer cold-start problem, and simpler alternatives dominate
+> (build the top-3 requested features natively, or integrate an existing automation platform).
+
+…followed by **7 anchored validation actions**, e.g. *"Pull the last 90 days of churned users and tag each
+with their primary churn reason"* (effort S, kill signal: churn isn't feature-driven). The full brief opens in
+your browser and has a **Copy report (Markdown)** button so you can paste it straight into your coding assistant.
+
+## Configuration
+
+Each provider runs its own model families — pick one per provider. Nothing is hardcoded, so a new model works
+the day it ships.
+
+```bash
+aiki models          # lists what each CLI offers
+```
+
+Set models, roles, and budget in `.aiki/config.json` (per-project) or `~/.aiki/config.json` (global default):
+
+```json
+{
+  "models": { "agy": "Gemini 3.1 Pro (High)", "claude": "opus", "codex": "gpt-5-codex" },
+  "roles":  { "judge": "claude" },
+  "budget": 18
+}
+```
+
+`roles` pins which provider judges and which review; `budget` is the max provider calls per run (a guard
+against repair storms — most runs use far fewer).
+
+## Sessions & resume
+
+Every run is recorded in a global registry (`~/.aiki/sessions.jsonl`), so you can find and continue runs from
+anywhere:
+
+```bash
+aiki sessions             # all runs, newest first, resumable ones flagged
+aiki resume <session-id>  # continue a killed/timed-out run (or /resume in the TUI)
+```
+
+Resume re-runs the pipeline but **replays** every step that already finished from the saved outputs on disk —
+so only the failed step onward spends a real model call. (A step that failed on bad *content*, not a crash,
+will replay that content; resume is for timeouts, crashes, and Ctrl-C.)
+
+## Safety model
+
+This is the part that makes aiki trustworthy to point at a real repo:
+
+- **Read-only orchestration.** Providers run with their read-only flags (`claude --permission-mode plan`,
+  `codex --sandbox read-only`, `agy --sandbox`). aiki never uses `--dangerously-skip-permissions` or any
+  edit/exec mode.
+- **No credentials, ever.** aiki never reads credential directories and filters `KEY|TOKEN|SECRET` out of the
+  environment before spawning a provider.
+- **Writes only under `.aiki/` / `~/.aiki/`.** Nothing else on your disk is touched.
+- **No API keys, no chat UI, no write/exec tools, no "learned" routing** — by design.
+- Skill playbooks load **only** from the repo and are scanned for exfiltration patterns before use.
+
+## Costs & limits
+
+- **Runs cost real model calls** against your existing CLI subscriptions/quota. Idea refinement is about
+  **12 provider calls** (~4 on Claude/Opus); code review is about **5**. `aiki run` shows an estimate and asks
+  to confirm (skip with `--yes`).
+- **Not a general assistant.** Questions and "explore my whole codebase" requests are redirected, not answered
+  — aiki reviews a *diff* and vets a *stated idea*.
+- **Analysis, not advice.** Every report is a decision aid. Verify before acting.
+- Every run leaves a full audit trail (each stage's prompt + raw output + intermediate artifacts) under its
+  run directory, and every stage's output is schema-validated before the next stage sees it — free-form prose
+  never crosses a stage boundary.
+
+## Where files live
+
+- Inside a git repo → the project's `.aiki/` (runs stay with the project).
+- Anywhere else → `~/.aiki/`. `$AIKI_HOME` overrides the global home.
+- The global session registry always lives in `~/.aiki/`.
+
+## How it works
+
+Every stage is a small, independently-testable unit with a zod-validated output contract. Model text lives in
+bounded, capped fields slotted into deterministic report structure — so the output is a briefing, not a chat
+transcript. The council's disagreement is the signal: consensus is trusted, disputes are adjudicated, and
+what nobody examined is flagged as a blind spot.
+
+## License
+
+MIT — see [LICENSE](LICENSE). Analysis, not advice — verify before acting.

package/dist/bench/arms.js

@@ -0,0 +1,104 @@
+// Benchmark arms A–D for code-review (§17, BENCHMARK.md §1, T11). Each arm is an engine composition:
+// the harness runs it via `executeRun` (→ a full .aiki/runs record) and it returns its final Finding[]
+// for scoring. A/B are single claude calls (the baselines); C is claude sampled 3× + self-consistency
+// synthesis; D is the full cross-provider pipeline. A/B/C use claude (the fixed "single best model").
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { CodeReviewRoleOutputModel } from '../schemas/index.js';
+import { jsonCall } from '../orchestration/jsonStage.js';
+import { parseDiffFiles } from '../orchestration/git.js';
+import { countLines, filterValidFindings } from '../orchestration/stages/cr-s4-review.js';
+import { sameFinding } from '../orchestration/stages/cr-map.js';
+import { s9ReviewJudge } from '../orchestration/stages/cr-s9-judge.js';
+import { scoreFindings } from '../orchestration/stages/cr-report.js';
+import { runCodeReview } from '../workflows/code-review.js';
+export const ARM_IDS = ['A', 'B', 'C', 'D', 'E'];
+const SCHEMA_LINE = 'findings: [{id "F1"..., file, line_start, line_end, severity P0|P1|P2|P3, category CORRECTNESS|SECURITY|CONCURRENCY|ERROR_HANDLING|PERF|MAINTAINABILITY, claim, evidence, suggested_fix, self_confidence 0-1}]';
+const A_PROMPT = `Review this code diff and report the bugs you find. The diff is at {{DIFF_PATH}} (repo root = your cwd).
+Output ONLY JSON: {task_echo (≤2 sentences), ${SCHEMA_LINE}}. JSON only.`;
+// Arm B — the real opponent: a single strong structured-adversarial prompt (analyze → self-attack → re-answer).
+const B_PROMPT = `You are a rigorous senior code reviewer. Review the diff at {{DIFF_PATH}} (repo root = your cwd) in three
+internal passes, then output ONLY the final JSON — do not show your working:
+1. ANALYZE: list every plausible defect (correctness, security, concurrency, error handling, performance).
+2. SELF-ATTACK: for each candidate, argue the strongest case that it is a FALSE POSITIVE; discard the ones that don't survive.
+3. RE-ANSWER: report only the surviving, defensible findings, each citing a file:line you verified exists.
+Output ONLY JSON: {task_echo (≤2 sentences), ${SCHEMA_LINE}}. severity P0 = correctness/security/data-loss. JSON only.`;
+/** Persist the diff + filled prompt, and return the reviewer-facing artifacts a single call needs. */
+async function setup(ctx, diff, template) {
+    await ctx.writer.writeInput('diff.patch', diff);
+    const files = parseDiffFiles(diff);
+    const prompt = template.replace('{{DIFF_PATH}}', resolve(ctx.writer.dir, 'inputs', 'diff.patch'));
+    await ctx.writer.writePrompt('reviewer.md', prompt);
+    return { prompt, files, diffSet: new Set(files), lineCounts: await countLines(ctx.cwd, files) };
+}
+/** A/B — one claude call, file:line-validated. `label` names the stage + role-output artifact. */
+async function singleCallArm(ctx, diff, template, label) {
+    const { prompt, diffSet, lineCounts } = await setup(ctx, diff, template);
+    const model = await jsonCall(ctx, ctx.handle('claude'), label, prompt, CodeReviewRoleOutputModel);
+    await ctx.writer.writeRoleOutput('claude', { workflow: 'code-review', ...model });
+    return filterValidFindings(model.findings, diffSet, lineCounts).valid;
+}
+export const armA = (ctx, diff) => singleCallArm(ctx, diff, A_PROMPT, 'A');
+export const armB = (ctx, diff) => singleCallArm(ctx, diff, B_PROMPT, 'B');
+/** Cluster findings across samples by the §487 matcher. Support = how many samples raised it. */
+function mergeSamples(samples) {
+    const clusters = [];
+    const rank = { P0: 0, P1: 1, P2: 2, P3: 3 };
+    for (const sample of samples) {
+        const claimed = new Set();
+        for (const f of sample) {
+            const c = clusters.find((cl) => !claimed.has(cl) && sameFinding(cl.rep, f));
+            if (c) {
+                claimed.add(c);
+                c.support += 1;
+                if (rank[f.severity] < rank[c.rep.severity])
+                    c.rep = f; // keep highest severity
+            }
+            else {
+                const nc = { rep: f, support: 1 };
+                clusters.push(nc);
+                claimed.add(nc);
+            }
+        }
+    }
+    // ≥2 samples → self-consistent consensus; exactly 1 → disputed (the judge decides keep/drop).
+    const claude = ['claude'];
+    const consensus = clusters.filter((c) => c.support >= 2).map((c) => ({ finding: c.rep, reviewers: [...claude], cross_verdict: 'NONE' }));
+    const disputed = clusters.filter((c) => c.support === 1).map((c) => ({ finding: c.rep, reviewers: [...claude], cross_verdict: 'REFUTE', refutation: 'appeared in only 1 of 3 samples' }));
+    let n = 0;
+    const reindex = (arr) => arr.map((a) => ({ ...a, finding: { ...a.finding, id: `G${++n}` } }));
+    return {
+        consensus: reindex(consensus),
+        disputed: reindex(disputed),
+        single_reviewer: [],
+        per_reviewer: [{ provider: 'claude', raised: samples.reduce((s, x) => s + x.length, 0), kept: clusters.length, dropped: 0 }],
+    };
+}
+/** Arm C — claude sampled 3× (sample-keyed self-consistency) + the code-review judge on singletons. */
+export const armC = async (ctx, diff) => {
+    const { prompt, diffSet, lineCounts } = await setup(ctx, diff, B_PROMPT);
+    const samples = [];
+    for (let i = 0; i < 3; i++) {
+        const model = await jsonCall(ctx, ctx.handle('claude'), `C-s${i + 1}`, prompt, CodeReviewRoleOutputModel);
+        await ctx.writer.writeRoleOutput(`sample-${i + 1}`, { workflow: 'code-review', ...model });
+        samples.push(filterValidFindings(model.findings, diffSet, lineCounts).valid);
+    }
+    const map = mergeSamples(samples);
+    await ctx.writer.writeJson('review-map', map);
+    const judge = await s9ReviewJudge(ctx, map); // ctx.roles.judge = claude for arm C (harness sets it)
+    return scoreFindings(map, judge).filter((s) => s.disposition === 'kept').map((s) => s.finding);
+};
+/** Arms D and E — the full product pipeline (`runCodeReview`) → read back its kept findings for scoring.
+ *  SAME pipeline; the harness injects their differing roles: D = claude+codex reviewers + agy judge;
+ *  E = agy+codex reviewers + claude judge (the Opus-thrift variant — claude fires only on disputes). */
+const productPipeline = async (ctx, diff) => {
+    await runCodeReview(ctx, diff);
+    const [map, judge] = await Promise.all([
+        readFile(resolve(ctx.writer.dir, '07-review-map.json'), 'utf8').then(JSON.parse),
+        readFile(resolve(ctx.writer.dir, '09-judge-report.json'), 'utf8').then(JSON.parse),
+    ]);
+    return scoreFindings(map, judge).filter((s) => s.disposition === 'kept').map((s) => s.finding);
+};
+export const armD = productPipeline;
+export const armE = productPipeline;
+export const ARMS = { A: armA, B: armB, C: armC, D: armD, E: armE };