Skip to content

mikeparcewski/wicked-garden / skills/core

wicked-garden-core

Flagged

Core utility surface for the wicked-garden plugin: help/overview, first-run setup + codebase onboarding, the wicked-* peer installer, selective state reset, the where-am-i path manifest, and structured issue filing. Use when: "wicked-garden help", "show wicked-garden commands", "what can wicked-garden do", "set up wicked-garden", "setup", "--reconfigure", "onboard this codebase", "install wicked tools", "add peers", "install layers", "reset wicked-garden", "clear state", "--list-projects", "where am I", "path manifest", "report issue", "file a bug", "--list-unfiled", or any former /wicked-garden:{help|setup|install|reset| where-am-i|report-issue} invocation.

FileKindSize
SKILL.mdskill md13.4 KB
refs/install.mdmarkdown5.3 KB
refs/inventory-report.mdmarkdown1.3 KB
refs/report-issue.mdmarkdown8.4 KB
refs/reset.mdmarkdown4.3 KB
refs/runtime.mdmarkdown4.2 KB
refs/setup.mdmarkdown23.5 KB
refs/templates.mdmarkdown2.3 KB

refs/setup.md

View on GitHub
# Action: setup

Configure wicked-garden connection and onboard the current codebase. The single
entry point for getting started. Always interactive — detects current state and
asks the user what they want.

## Arguments

- `--reconfigure`: Force connection reconfiguration even if already set up

## Question Mode

Detect once, branch every interactive call site below:

```bash
wicked-garden run scripts/setup/detect_state.py question-mode
```

- **INTERACTIVE**: Use your harness's native question prompt as documented in each step.
- **PLAIN_TEXT**: no usable native prompt (dangerous mode auto-completes with empty answers; most CLIs have none). Present every question as a **numbered plain text list**, then **STOP and wait** for the user. Do NOT proceed until you receive a reply.
- The detector keys on the Claude harness's dangerous-mode flag only: on any other seat read PLAIN_TEXT regardless of its answer.

## Answer Verification (CRITICAL)

**INTERACTIVE (native prompt) mode**: after EVERY prompt answer you MUST (1) verify the selection is clearly present in the response, (2) echo it back — "You selected **[option]**. Proceeding with [action]..." — before any action, (3) if ambiguous or empty, do NOT assume — ask "I couldn't determine your selection. Could you tell me which option you'd like?" and wait.

**PLAIN_TEXT mode**: present options as a numbered list, **STOP**, parse the reply, echo back the same way. Never proceed with a default. Wrong actions are worse than asking twice.

## Instructions

### 1. Detect Current State

```bash
wicked-garden run scripts/setup/detect_state.py config
```

Returns `{"present": false, "path": ...}` if no config, otherwise `{"present": true, "path": ..., "config": {...}}`. This determines which questions to ask in Step 3.

### 2. Install Prerequisites

```bash
wicked-garden run scripts/_run.py scripts/platform/prereq_doctor.py check-all
```

Parse the JSON. Only `core` tools are required during setup. For each `core` tool: `status: "available"` → checkmark; `status: "missing"` → show "{name} is not installed. Install with: `{install_cmd}`?" then **INTERACTIVE mode**: native prompt header "{name}", options "Install now" = "Run: {install_cmd}" / "Skip" = "Continue without {name}"; **PLAIN_TEXT mode**: ask in plain text and STOP. If approved, run `install_cmd` (and `post_install` if present), then re-check with `prereq_doctor.py check {tool}`. If declined, warn dependent features will be unavailable and continue. **Skip `optional` tools** — the PostToolUseFailure hook detects them at runtime.

After core tools, if `uv` is available, sync Python deps: `{uv_path} sync --quiet`. If sync fails, warn that search indexing will be unavailable but continue.

> **One required, two recommended/opt-in.** The evidence gate needs **wicked-vault** (§2.6) — it installs directly as a self-contained infra peer, and the internal loom engine is built into wicked-garden itself, so no separate loom install is needed. **wicked-estate** (§2.5b) is the memory/context layer — recommended; **wicked-bus** is an opt-in audit-trail layer. Skip either and the rest of the toolkit still works. Evidence-gated acceptance testing needs no install: the `qe` domain ships in-catalog.

### 2.5b Verify wicked-estate (Recommended — memory/context layer)

wicked-estate is a Rust binary pair (`wicked-estate` CLI + `wicked-estate-mcp` MCP server). Hooks resolve it via `WICKED_ESTATE_MCP_BIN` → PATH → `~/.local/bin`, so verify by presence:

```bash
wicked-garden python - <<'PY' 2>/dev/null || python - <<'PY'
import os, shutil
from pathlib import Path
override = os.environ.get("WICKED_ESTATE_MCP_BIN")
found = (override and Path(override).is_file()) or shutil.which("wicked-estate-mcp") \
    or (Path.home()/".local"/"bin"/"wicked-estate-mcp").is_file()
print("READY" if found else "MISSING")
PY
```

- `MISSING` → **recommended, not blocking.** wicked-estate is the memory/context layer (cross-session memory, knowledge recall with citations, the code graph behind `wicked-garden-search`); the rest of the toolkit works without it — hooks fail open. Show "wicked-estate isn't installed — you'll lose cross-session memory + knowledge recall until you add it (binaries `wicked-estate` + `wicked-estate-mcp` on PATH or ~/.local/bin)." Continue setup either way.
- `READY` → show "wicked-estate — ready (binary present)."

### 2.5c Verify wicked-understanding (Recommended — repo-playbooks layer)

wicked-understanding installs as **`skills`-standard skills** (multi-CLI; no server). It analyzes the current repo at HEAD into task playbooks (`fix-bug`/`add-feature`/`verify`/`write-tests`) the agent loads on demand — the "how to work in THIS repo" layer that pairs with the knowledge layer's "what". Per-repo, so verify by presence of its generated skills rather than a version probe.

```bash
wicked-garden python - <<'PY' 2>/dev/null || python - <<'PY'
import os
from pathlib import Path
found = False
roots = [Path.home()/".claude"/"skills"]
cfg = os.environ.get("CLAUDE_CONFIG_DIR")
if cfg: roots.append(Path(cfg)/"skills")
for r in roots:
    try:
        if r.exists() and any(e.is_dir() and e.name.startswith(("repo-", "fix-bug", "add-feature")) for e in r.iterdir()):
            found = True; break
    except OSError: continue
print("READY" if found else "ABSENT")
PY
```

- `ABSENT` → **recommended, not blocking.** Show "wicked-understanding isn't set up — without it the agent re-derives *how to work in this repo* each task. Add the repo-playbooks layer: `npx skills add mikeparcewski/wicked-understanding --all`, then run its `repo-analyst` to generate this repo's playbooks." **INTERACTIVE mode**: native prompt header "wicked-understanding (optional layer)", options "Install now" = "Run: npx skills add mikeparcewski/wicked-understanding --all" / "Skip" = "Continue without repo playbooks". **PLAIN_TEXT mode**: offer the choice and CONTINUE. If skipped: continue setup.
- `READY` → show "wicked-understanding — ready (repo playbooks installed)." Suggest re-running `repo-analyst` after large changes so the playbooks track HEAD.

### 2.6 Verify wicked-vault (Required — the evidence gate)

```bash
npx wicked-vault --version 2>/dev/null || echo "MISSING"
```

- `MISSING` → blocking. wicked-vault is the evidence backend every archetype gate re-derives against — without it, "done" can only be self-asserted. Show "wicked-vault is not installed. wicked-garden requires it as a direct infra peer (sibling to wicked-bus)." **INTERACTIVE mode**: native prompt header "wicked-vault Required", options "Install now (Required)" = "Run: npm i -g wicked-vault" / "Exit setup" = "Cancel — I'll install manually and re-run". **PLAIN_TEXT mode**: present numbered options and STOP. If install: run `npm i -g wicked-vault` (puts the `wicked-vault` binary on PATH) and confirm the CLI resolves with `npx wicked-vault --version`. On failure, show stderr and exit with manual instructions (`npm i -g wicked-vault`). If exit: "Run `npm i -g wicked-vault` then restart by invoking the wicked-garden-core skill's `setup` action."
- Version string → compare it against the declared peer floor **≥ 0.8.0** <!-- vault-floor --> (single source: `scripts/loom/manifest.py` `version_pin`, lockstep with plugin.json `wicked_vault_version`). **Below the floor** (e.g. `0.7.0`) → tell the user to upgrade: "wicked-vault {version} is below the floor 0.8.0 — peer health checks (`loom doctor` / peer-health) report it as drift and fail. Upgrade: `npm i -g wicked-vault@latest`." At or above (e.g. `0.8.0`) → show "wicked-vault {version} — ready." Then verify the garden can resolve it for gating: `wicked-garden run scripts/qe/vault_gate.py resolve` should report `resolvable: true`. If `installed: false` (resolving only via npx), suggest `npm i -g wicked-vault` for faster gate latency — recommended, not a hard block.

### 2.7 Verify wicked-bus (Recommended — audit-trail layer)

wicked-bus installs from npm (`npm i -g wicked-bus`), and `npx wicked-bus-install` copies its skills into detected AI CLIs, so verify by presence of those skills rather than a version probe.

```bash
wicked-garden python - <<'PY' 2>/dev/null || python - <<'PY'
import json, os
from pathlib import Path
installed = False
candidates = [Path.home()/".claude"/"settings.json", Path(".claude")/"settings.json"]
cfg = os.environ.get("CLAUDE_CONFIG_DIR")
if cfg: candidates.append(Path(cfg)/"settings.json")
for p in candidates:
    try:
        if not p.exists(): continue
        enabled = json.loads(p.read_text(encoding="utf-8")).get("enabledPlugins", {})
        if "wicked-bus" in (enabled if isinstance(enabled, (dict, list)) else {}):
            installed = True; break
    except Exception: continue
if not installed:
    roots = [Path.home()/".claude"/"skills"]
    if cfg: roots.append(Path(cfg)/"skills")
    for r in roots:
        try:
            if r.exists() and any(e.is_dir() and e.name.startswith("wicked-bus") for e in r.iterdir()):
                installed = True; break
        except OSError: continue
print("READY" if installed else "MISSING")
PY
```

- `MISSING` → **recommended, not blocking.** wicked-bus is the audit-trail layer; event emission is already fire-and-forget / fail-open, so the toolkit runs fine without it (events just aren't recorded). Show "wicked-bus isn't installed — the cross-session audit trail will be empty until you add it." **INTERACTIVE mode**: native prompt header "wicked-bus (optional layer)", options "Install now" = "Run: npm i -g wicked-bus && npx wicked-bus-install" / "Skip" = "Continue without the audit trail". **PLAIN_TEXT mode**: offer the choice and CONTINUE. If install: run `npm i -g wicked-bus && npx wicked-bus-install` (terminal commands — the installer copies the bus skills into the detected AI CLIs' skills directories), then re-run the presence check and confirm `READY`. If skipped: continue setup.
- `READY` → show "wicked-bus — ready (skills installed)."

### 2.7b Verify loom peer-resolution engine (internal — no external install needed)

After Phase B of the ecosystem rationalization, the loom peer-resolution engine is absorbed
directly into wicked-garden as `scripts/loom/`. No external loom npm package is required. Check that the internal module is importable:

```bash
wicked-garden python -c "
import sys, os
sys.path.insert(0, os.path.join(os.environ["WICKED_GARDEN_ROOT"], 'scripts'))
try:
    from loom import resolve, compose, gate, manifest
    print('READY')
except ImportError as e:
    print('MISSING: ' + str(e))
"
```

- `READY` → show "Loom peer-resolution — ready (internal module available). Peer resolution, vault gating, and peer-health checks are fully operational."
- `MISSING: ...` → this indicates a wicked-garden installation problem. Show "The loom internal module could not be imported from `scripts/loom/`. This is a garden install error — reinstall wicked-garden via the marketplace." This is blocking; do not proceed until resolved. **Note**: `WICKED_LOOM_BIN` overrides to an external loom binary (debugging escape hatch); `WICKED_LOOM_CUTOVER=off` is an emergency kill-switch that disables the gate entirely and causes it to FAIL CLOSED — there is no fallback/graceful-degradation path when the kill-switch is active. It is not a rollback mode; it is an emergency stop. Do NOT set it except under explicit incident direction.

### 2.8 v6→v11 Project State Migration (optional)

If the user has v6-v10 crew projects on disk, advise them to run the v11 migration script:

```bash
wicked-garden run scripts/setup/migrate_v6_projects.py
```

`CLEAN` → no v6-state found, skip silently. `MIGRATABLE_FOUND` → list affected projects and ask whether to translate them to v11 archetype-mode shape. The legacy qe-evaluator naming sweep that lived here in v6 was removed when the universal pipeline was deleted in v11.0.0.

### 3. Ask the User (batched questions)

Method depends on Question Mode.

#### 3a. If config exists (setup_complete: true)

**Q1 — Onboarding**: "Would you like to run codebase onboarding?" Options: "Full onboarding (Recommended)" | "Quick scout" | "Skip for now". **INTERACTIVE mode**: native prompt with header "Onboarding" (Full = "Index the codebase, explore architecture, trace flows, save discoveries as memories, and write the build/test guide (runs the test suite). Indexing takes 1-2 minutes; the guide takes as long as a few test runs.", Quick scout = "Fast reconnaissance without indexing.", Skip = "Skip onboarding. Run the wicked-garden-core `setup` action later."). **PLAIN_TEXT mode**: present numbered text (a/b/c with same descriptions) and STOP. Verify, echo back. Skip to Step 5 with the answer.

#### 3b. If NO config

**Q1 — Onboarding**: same as 3a. Storage is always local (DomainStore writes local JSON) — no connection setup needed. After answer: Step 4 (write config) → Step 5.

### 4. Write Config (if needed)

```bash
wicked-garden run scripts/setup/onboarding.py write-local-config
wicked-garden run scripts/setup/onboarding.py mark-setup-complete
```

Show: "Storage configured! Mode: Local (DomainStore — local JSON files). Status: Ready."

### 5. Run Onboarding

Execute based on the onboarding answer from Step 3.

#### 5.0 Environment Scan (Full and Quick paths only)

Skip this step if the user chose "Skip".

```bash
wicked-garden run scripts/setup/detect_state.py project-env
wicked-garden run scripts/_run.py scripts/platform/prereq_doctor.py check-all
```

Store as `DETECTED_LANGS`, `DETECTED_FWS`. Build `DETECTED_TOOLS` from combined `core` + `optional` where `status` is `"available"`.

**Domain preferences** — which issue tracker? **INTERACTIVE mode**: native prompt header "Issue Tracking" with the 4 most common (native prompts support max 4): "GitHub Issues" = "Use gh cli" / "Jira" = "Use Jira API" / "Azure DevOps" = "Use Azure DevOps work items" / "Local tasks only" = "Use the coding agent's native tasks only (default)". Let the user select "Other" for Linear or Rally. **PLAIN_TEXT mode**: write default `local` without asking (dangerous-mode sessions should not block on preferences).

**Validate the selected tool is reachable** (skip for `local`):

```bash
wicked-garden run scripts/_run.py scripts/platform/prereq_doctor.py check "{selection}"
```

- `available` + `via: "mcp"` → show "**{name}** connected via MCP server `{mcp_server}`."
- `available` + `via: "cli"` → show "**{cli}** CLI found at {cli_path}."
- `missing` → "**{name}** is not installed. Install with: `{install_cmd}`?". **INTERACTIVE mode**: native prompt header "{name}", options "Install now (Recommended)" = "Run: {install_cmd}" / "Skip" = "Use local native tasks instead". **PLAIN_TEXT mode**: ask in plain text and STOP. If approved, run `install_cmd` (and `post_install` if present), re-check with `prereq_doctor.py check {selection}`. If declined, override to `local`.

Persist the selection (one of `github` | `linear` | `jira` | `ado` | `rally` | `local`):

```bash
wicked-garden run scripts/setup/onboarding.py save-domain-pref {selection}
```

#### 5.1 Full Onboarding

Runs the **knowledge pipeline** — build the code graph, ingest the codebase into the knowledge store, store onboarding context. Show progress as each step completes. If any step fails, log it and continue — each step is independently valuable.

First, ask which directories to onboard. **INTERACTIVE mode**: native prompt with header "Directories", options "Current directory (Recommended)" = "Onboard the project root: {cwd}" / "Specify directories" = "Choose specific directories to index (enter paths via Other)". **PLAIN_TEXT mode**: ask in plain text (a = current directory `{cwd}`, b = specify paths), STOP, wait, verify, echo back.

##### Knowledge Pipeline (in order)

**Step A — Verify wicked-estate** (§2.5b probe). If MISSING, skip Steps B–C (log it) and still do Step D's best effort — the mem backend degrades gracefully.

**Step B — Build the code graph**. Show "Indexing code graph..." then run `wicked-estate index {selected_directory}` (binary via `WICKED_ESTATE_BIN` → PATH → `~/.local/bin`; DB defaults to `.wicked-estate/graph.db`). This powers blast-radius/lineage/hotspots.

**Step C — Ingest codebase knowledge**. Show "Ingesting codebase into the knowledge store..." then run the Hand-off below — the mem skill dispatches its ingest worker (text chunked deterministically, binary docs via LLM vision, provenance on every chunk).

**Hand-off** — open the `wicked-garden-mem` skill and run its `ingest` action with `{selected_directory}` as the argument; on Claude Code this is the Skill tool, on any other seat open the named skill from your catalog and carry it out inline, then continue here.

**Step D — Record the onboarding scan as knowledge**. `{DETECTED_TOOLS_SUMMARY}` lists only available tools (e.g. "gh, docker"). Languages, frameworks and tools were read from the repository, so they are knowledge, not memory:
**Hand-off** — open the `wicked-garden-mem` skill and run its `write` action with content `{project} project context: languages {DETECTED_LANGS}; frameworks {DETECTED_FWS}; tools available {DETECTED_TOOLS_SUMMARY}.`, `class=concept` and `source={selected_directory}`; on Claude Code this is the Skill tool, on any other seat open the named skill from your catalog and carry it out inline, then continue here.

**Step E — Write the build/test guide**. The wicked-core floor reads `.wicked/build-guide.json` (how this repo runs its tests, reads their results, lists, runs one and deselects a test) from the base tree. Without a guide, the floor runs the repo's checks exit-code only. Show "Discovering how this repo builds and tests..." then run the Hand-off below. It reads CI config and manifests, writes a mutation probe, validates the guide with `wicked-core floor probe`, and proposes the file as a PR. It never writes the file silently. Record its outcome as `{BUILD_GUIDE}`: `proposed (PR <link>)`, `unverified (probe unavailable)`, `none (exit-code only): <reason>`, or `already present`. If `.wicked/build-guide.json` already exists, skip this step and record `already present`.
**Hand-off** — open the `wicked-garden-build-guide` skill and run its `discover` action with `{selected_directory}` as the repo; on Claude Code this is the Skill tool, on any other seat open the named skill from your catalog and carry it out inline, then continue here.

Show: "Onboarding complete — knowledge store has {N} chunks (mem review reports totals)."

#### 5.2 Quick Scout

Ask which directories to scout (same question mode pattern as 5.1 — native prompt or plain text depending on mode). Then Glob/Read the key entry points and record the detected context from Step 5.0 as knowledge (it was read from the repository):

**Hand-off** — open the `wicked-garden-mem` skill and run its `write` action with content `{project} project context (quick scout): languages {DETECTED_LANGS}; frameworks {DETECTED_FWS}; tools {DETECTED_TOOLS_SUMMARY}.`, `class=concept` and `source={project}`; on Claude Code this is the Skill tool, on any other seat open the named skill from your catalog and carry it out inline, then continue here.

Quick scout skips the build/test guide, because writing it runs the test suite several times. Record `{BUILD_GUIDE}` as `not run (invoke wicked-garden-build-guide to write it)`.

#### 5.3 Skip

Store a skip memory so the bootstrap directive doesn't fire again:
**Hand-off** — open the `wicked-garden-mem` skill and run its `store` action with the memory text `Onboarding: {project} skipped by user on {date}. Invoke the wicked-garden-core skill's setup action to onboard later.` and `kind=skill, about=[onboarding, {project}]`; on Claude Code this is the Skill tool, on any other seat open the named skill from your catalog and carry it out inline, then continue here.

### 6. Clear Onboarding Gate

Set `{mode}` to `full` / `quick` / `skip`. Pass `--complete` for full/quick (omit for skip):

```bash
wicked-garden run scripts/setup/onboarding.py clear-gate --mode {mode} [--complete]
```

### 6.5 Inject CLAUDE.md Hints

**Hand-off (harness-specific)** — on Claude Code only: inject a minimal wicked-garden hint block into `.claude/CLAUDE.md` so the agent discovers the plugin in future sessions; on any other seat skip this step (the seat's own instructions file is the operator's). Rules: target `.claude/CLAUDE.md` in the working directory (create the directory if needed); idempotent — if a `## Wicked Garden` section already exists, skip entirely; non-destructive — append to end; ultra-condensed (~80 tokens). If the file is created new, prepend `# Project Instructions\n\n` before the section. **Skip mode still injects** — the user should know the plugin is available even if onboarding was skipped.

Append (or prepend with header for a new file):

```markdown

## Wicked Garden

This project uses the [wicked-garden](https://github.com/mikeparcewski/wicked-garden) plugin.

Before implementing manually, check if wicked-garden has a skill for it:
- Code review: invoke the `wicked-garden-engineering` skill (`review` action)
- Brainstorm/decide: invoke the `wicked-garden-jam` skill (`quick "your question"`)
- Security/compliance: invoke the `wicked-garden-platform` skill (`security` action)
- Any task: describe it (the hook routes to a work-shape archetype) or invoke
  the `wicked-garden-archetype` skill directly, e.g. `build "description"`

Invoke the `wicked-garden-core` skill for help with all available skills.
```

### 6.6 Enable the work-mode status line (optional)

Offer to surface the detected archetype on screen. **INTERACTIVE mode**: native prompt header "Status line", options "Enable (Recommended)" = "Show the live work mode at the bottom of the screen" / "Skip" = "Don't change my status line". **PLAIN_TEXT mode**: ask in plain text and STOP.

If enabled, add (non-destructively — skip if a `statusLine` key already exists) to the user's `settings.json`. The status line runs outside any plugin context, so it uses the launcher, which resolves the plugin root itself (`npm i -g wicked-garden` puts `wicked-garden` on PATH; without it, substitute `<root>` with the output of `wicked-garden root` and use `python3 "<root>/scripts/statusline.py"`):

```json
"statusLine": {
  "type": "command",
  "command": "wicked-garden run scripts/statusline.py"
}
```

The bar then shows `🌱 wg │ <archetypes> │ intent · phase · gate verdict`. It reads session state only, is fail-soft, and never blocks a render. If a `statusLine` is already set, show the snippet and let the user merge it manually rather than overwriting.

### 7. Done

Show:

```
wicked-garden is ready!

Storage:         Local (DomainStore)
wicked-estate:   {"ready (binary present)" or "MISSING — memory/context layer degraded"}
wicked-bus:      {"ready (skills installed)" or "MISSING — install required"}
wicked-vault:    {version e.g. "0.8.0 — ready" or "MISSING — install required" or "{version} — below the 0.8.0 floor, upgrade required"}
loom engine:     {"ready (internal — scripts/loom/)" or "MISSING — garden installation problem"}
Onboarding:      {Full | Quick scout | Skipped}
Directories:     {paths onboarded}
Build guide:     {BUILD_GUIDE, or "skipped"}
Project type:    {DETECTED_LANGS} / {DETECTED_FWS} (or "Not detected")
Integrations:    {available tools, or "None detected"}
Preferences:     Delivery → {selected issue tracker}

Quick start: wicked-garden-core (help) · wicked-garden-archetype (build) ·
wicked-garden-prove (compile) · wicked-garden-engineering (review) ·
wicked-garden-mem (recall "query")
```

## Graceful Degradation

- Connection setup fails → local JSON fallback handles storage automatically.
- Onboarding indexing fails → fall back to quick scout.
- Memory store fails → still complete (just won't suppress future directives).
- Never block the user from working — all failures offer alternatives.
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 322kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 322kUpdated Claude CodeCodexVerifiedInstall