workflow

agentic-toolkit

Personal collection of agentic coding skills. Compatible with Claude Code, Codex, OpenCode, Cursor, Gemini CLI, and 40+ other tools via npx skills add.

Contents

• Install — ask an agent · conflicts · Claude Code · Codex · OpenCode · Cursor · manual
• Skills — the standalone skills table
• Condux — the agentic workflow bundle
• Concord — continuous memory for Codex
• Docket — file-based project backlog
• Toolkit Ops — maintaining this repo
• Where artifacts land — what gets written to your project, and where
• Evals — how trigger routing is measured
• Acknowledgments
• Structure — repo layout and the four distribution channels

Install

npx skills add auto-detects the running agent and installs to the right directory:

npx skills add jabworks/agentic-toolkit

This works inside Claude Code, Codex, OpenCode, Cursor, and most other agentic tools — no flags needed.

Ask an agent to install it

The marketplace install is only half the job for condux, docket and concord — each finishes with a host-specific step no marketplace can perform. Every one of them ships an INSTALL.md written to be followed by an agent, so the shortest path is to hand the whole thing to the agent you already have open. Paste this:

Install plugins from the jabworks/agentic-toolkit marketplace on this machine.

1. Detect the host you are running in — Claude Code (~/.claude), Codex
   ($CODEX_HOME or ~/.codex), or OpenCode (~/.config/opencode).

2. Add the marketplace and install the plugins I named. If I did not name any,
   ask me first — do not install all of them.
     Claude Code   /plugin marketplace add jabworks/agentic-toolkit
                   /plugin install <plugin>@jabworks-agentic-toolkit
     Codex         codex plugin marketplace add jabworks/agentic-toolkit
                   codex plugin add <plugin>@jabworks-agentic-toolkit
     OpenCode      add "@jabworks/condux" to the plugin array in opencode.json

3. Three plugins need a step the marketplace cannot do. Read the INSTALL.md
   next to each one you installed, then run its installer:
     condux    <plugin-root>/install.mjs
     docket    <plugin-root>/skills/docket/record/server/install.sh
     concord   <plugin-root>/skills/concord/remember/references/install-codex-hook.sh
   Show me the --dry-run plan before writing anything.

4. Verify rather than assume — run the doctor for each plugin and show me the
   report as it printed:
     /condux:condux-doctor    /docket:docket-doctor    /concord:concord-doctor

5. Report one row per host: what you changed, what was already correct, and
   what any doctor flagged. If one warns that another installed skill library
   conflicts, show me its removal command but do not remove anything.

Every step is safe to re-run, and each installer is read-modify-write on one key — none of them rewrites config another plugin owns.

Compatibility with other skill libraries

condux conflicts with obra/superpowers — the library it reworks. Both register a SessionStart hook on the same matcher, each injecting a router claiming every dev task, and 11 of superpowers' 14 skills overlap 8 of condux's. Run one or the other. install.mjs and /condux:condux-doctor both detect it and print the removal command without running it; the overlap table and reasoning are in the condux README, and the registry driving the check is skills/condux-doctor/conflicts.json.

No other conflict is currently detected. The rest of the toolkit's skills — git, release, spec, session — occupy their own ground.

Claude Code — plugin marketplace

Alternatively, register as a plugin marketplace to install individual skills:

Via CLI:

claude plugin marketplace add jabworks/agentic-toolkit
claude plugin install session-handoff@jabworks-agentic-toolkit # claude plugin install session-handoff
claude plugin install toolkit-ops@jabworks-agentic-toolkit # claude plugin install toolkit-ops

Via Claude Code CLI:

/plugin marketplace add jabworks/agentic-toolkit
/plugin install session-handoff@jabworks-agentic-toolkit # /plugin install session-handoff
/plugin install toolkit-ops@jabworks-agentic-toolkit # /plugin install toolkit-ops

Via Claude Code CLI plugin menu:

/plugin
-> Marketplaces tab -> Add Marketplace -> jabworks/agentic-toolkit
-> Discover tab -> Search plugin name

Codex — plugin manifests

This repo is also Codex plugin compatible:

Via CLI:

codex plugin marketplace add jabworks/agentic-toolkit
codex plugin add session-handoff@jabworks-agentic-toolkit
codex plugin add toolkit-ops@jabworks-agentic-toolkit

Via Codex CLI plugins menu:

/plugins
-> Add Marketplace -> jabworks/agentic-toolkit
-> Select jabworks/agentic-toolkit tab to add plugins

OpenCode — condux plugin + merged-trigger skill variants

For the condux workflow, one plugin line is the whole install. The @jabworks/condux plugin bundles the 16 condux skills, injects the specialist agents (coder / explorer / planner / researcher), and wires an opt-in plan-review listener:

// opencode.json
{
  "plugin": ["@jabworks/condux"]
}

The bundled skills register themselves on config.skills.paths, so no separate skills install is needed for condux.

For the rest of the toolkit skills (git-commit, session-handoff, release, spec-browser, coding-directive, …), install the OpenCode-facing variants. These fold each skill's when_to_use trigger conditions into its description — OpenCode surfaces only description when deciding which skill to load, so the plain skills/ tree would lose them:

npx skills add https://github.com/jabworks/agentic-toolkit/tree/main/dist/opencode/skills -a opencode

This copies skills into ~/.config/opencode/skills/. It also includes the condux skills, but the plugin already provides those — OpenCode dedupes by name, so installing both is harmless.

Cursor — merged-trigger skill variants

Cursor loads SKILL.md natively (since Cursor 2.4) but surfaces only description when deciding which skill to load — it never reads when_to_use. Install the Cursor-facing variants, which fold the trigger conditions in (same transform as the OpenCode tree):

npx skills add https://github.com/jabworks/agentic-toolkit/tree/main/dist/cursor/skills -a cursor

Run it in your project — skills land in .agents/skills/, which Cursor picks up per-project. Prefer project installs over --global: the CLI currently writes global skills to ~/.agents/skills/ against its own docs (vercel-labs/skills#421), and on a WSL setup that's the WSL home while Windows-side Cursor reads C:\Users\<you>\.agents\skills\ — the install silently vanishes.

Most plugins are also spec-conformant Agent Plugins (root plugin.json, flat skills/, docket MCP via spec mcp.json) — Cursor loads them directly. To try one without a marketplace: copy dist/plugins/<name> into ~/.cursor/plugins/local/<name> and fully restart Cursor. Plugin installs ship raw skill frontmatter, so the trigger-quality caveat below applies; the dist/cursor/skills/ install remains the best path for auto-triggering.

condux and concord are not Agent Plugins and won't load by that path. Codex picks its plugin loader by root-manifest presence, and the Agent Plugins loader has no hooks — shipping the manifest silently disabled every Codex hook those two have. Hooks are the point of both, so they ship without it. On Cursor use dist/cursor/skills/ for them, which is the better channel there anyway.

Verified end-to-end 2026-08-14 (Cursor on Windows, WSL remote):

Bonus: if Claude Code is installed on the same machine, Cursor picks up its plugin ecosystem by itself — already-installed plugins (skills and MCP servers, docket included) just appear, and registered marketplaces surface in Cursor's Customize panel with one-click Add. Marketplace installs ship the raw SKILL.md, whose when_to_use Cursor ignores — fine for MCP-bearing plugins like docket, but for reliable skill triggering prefer the dist/cursor/skills/ install above. Cursor reads the marketplace clone on its own side of a WSL split, which can lag — update the marketplace in Claude Code if the listing looks stale.

Manual fallback

If running outside an agent environment, clone and copy to your tool's skills directory:

git clone https://github.com/jabworks/agentic-toolkit /tmp/agentic-toolkit
cp -r /tmp/agentic-toolkit/skills/<name> <skills-directory>/

Skills

<!-- catalog:begin readme-skills -->

<!-- catalog:end readme-skills -->

Condux

Lean agentic workflow plugin (condux). Install the full workflow bundle as a unit:

/plugin install condux@jabworks-agentic-toolkit

Inspired by obra/superpowers — condux reworks its skill-orchestration ideas around a lean, proportional-effort philosophy (tiered routing, lazy loading, soft gates) rather than always-on maximalism.

Installing is the whole setup: condux ships a SessionStart hook (Claude Code and Codex both) that puts its routing rule in context before your first prompt, so /workflow is reached as the entry point instead of being inferred from the skill catalog. That inference sits at roughly 80% on its own, and the misses are condux's own siblings winning the query — root-cause-analysis on a crash report, draft-plan on "write the plan" — which no description can fix without stealing their trigger space. The payload is ~390 tokens per session and lives in skills/workflow/hooks/routing.md; delete or edit that file to change or disable it.

Why condux

Most workflow frameworks are maximal — every gate runs on every task, so a typo fix pays the same ceremony as a cross-cutting refactor. Condux inverts that with five operating rules:

1. Proportional, not maximal — the process tier matches the task size.
2. Lazy loading — downstream skills load only when their step is reached, keeping context (and cost) small.
3. Soft gates, not hard walls — a gate can be skipped, but only consciously: the agent asks before bypassing, never silently.
4. The user is in control — explicit instructions always beat the framework; "treat this as LARGE" or "skip the plan" is always valid.
5. Implement yourself by default — subagents are the exception and need a concrete justification, never spawned to fill time.

The payoff: no over-engineered button changes, no under-planned refactors, predictable checkpoints where you drive every transition, and a small context footprint because only the skills a tier actually needs ever load.

The flow

Every dev task enters through /workflow. It infers a tier from the task (file count, design clarity, boundary crossings), confirms it with you, then runs the matching pipeline:

flowchart TD
    T([dev task]) --> W{"/workflow — infer tier, confirm"}
    W -->|SMALL| S[implement]
    W -->|MEDIUM| M["inline plan"] --> M2[implement]
    W -->|LARGE| L["/discovery"] --> L2["/draft-plan"] --> L3[implement]
    S --> F["/preflight → /finalize"]
    M2 --> F
    L3 --> F

Every tier ends with /preflight (an "am I actually done?" checklist) and /finalize (typecheck → lint → format → test, in order, once, stopping on the first failure) — quality checks run at the end, not scattered mid-implementation.

Checkpoints (MEDIUM/LARGE only): at each phase boundary the agent stops and presents a menu — after the plan (start implementing / tests-first / spawn agents / revise), after implementation (verify & finalize / code review / keep building), and after everything is green (review / commit / release / done). The agent never auto-advances past a checkpoint; SMALL runs linear with no menus.

Named agents: five specialists ship with the bundle — explorer (read-only codebase navigation), researcher (external API/library verification), planner (design → executable plan), coder (executes a provided plan), and scout (one angle of a /condux:research survey). Pipeline: explorer/researcher gather → planner plans → coder executes → finalize validates. The default is still to implement directly — agents are opt-in at checkpoints or justified by genuinely parallel work.

The skills

<!-- catalog:begin readme-condux -->

<!-- catalog:end readme-condux -->

Concord

Continuous memory for Codex (concord) — the remember skill plus its doctor:

/plugin install concord@jabworks-agentic-toolkit

Three Codex hooks share one idempotent operation — sync the rollout forward from its recorded position — so capture is exactly-once regardless of hook order, and a hard-killed session is recovered at next start rather than lost. Memory ages through buffer, daily, recent, and archive tiers; explicitly pinned facts are never auto-compressed. references/install-codex-hook.sh wires the hooks; concord-doctor tells you whether they are still wired.

Docket

File-based project backlog plugin (docket) — two skills plus machinery:

/plugin install docket@jabworks-agentic-toolkit

Open items live in docket/DOCKET.md, closed items move to docket/archive/<year>.md with verification records, and ids are never reused — #N in a commit subject refers to the docket, not GitHub. The record skill captures and closes items; groom sweeps for stale and ghost work and recommends what to pick next. A dependency-free CLI (server/docket.mjs) keeps id allocation and archive moves byte-exact, a bundled MCP server exposes the same ops as tools (auto-registered on Claude Code; server/install.sh or the agent-followable server/INSTALL.md registers it for Codex/OpenCode), and docket.mjs browse renders a self-contained HTML board. Legacy root BACKLOG.md layouts are detected and work in place — migration is offered, never forced.

Toolkit Ops

Repo-maintenance bundle (toolkit-ops) for working on this toolkit itself:

/plugin install toolkit-ops@jabworks-agentic-toolkit

<!-- catalog:begin readme-toolkit-ops -->

<!-- catalog:end readme-toolkit-ops -->

Where artifacts land

Skills that write files into your project follow one rule: durable output goes to a normal project path; working state goes to .<plugin-name>/ at the git root, gitignored.

<git-root>/
  specs/              # durable — tech specs, committed, browsable via spec-browser
  .condux/            # working state — designs/ plans/ progress/ scratch/
  .session-handoff/   # working state — handoff docs
  .session-report/    # working state — generated HTML usage reports

The spec is what you keep; the design and plan are scaffolding it was built from. Directories are named for the owning plugin, not the skill and not the artifac