Agent Plugins Marketplace
All plugins

forge

v0.9.0

Agent-engineering workflow skills for Claude Code, Codex, and opencode — twenty-two fg-* skills: the four-stage loop (fg-ask → fg-run → fg-learn → fg-done) plus outside-the-loop utilities, including fg-security (vendored security audit) and fg-debug (vendored diagnosis only: active failures return to fg-run; independent diagnoses route by size, durable eval, and all-exit safe cleanup).

CodexClaude Code17 Skills

By gyuhaLicense: MIT4 GitHub starsUpdated 2 weeks ago

Directory evidence

Runtimes
Codex and Claude Code
Parsed components
17 skill or MCP entries
Source updated
Sep 10, 2026
Manifest status
Canonical path parsed

The directory validates manifest shape and source location. It does not execute the plugin or provide a security endorsement. Review the indexing methodology

Install forge for Codex and Claude Code

Installs for the current user
codex plugin marketplace add IchenDEV/agent-plugin-mkt
codex plugin marketplace upgrade agent-plugin-marketplace
codex plugin add forge@agent-plugin-marketplace

Paste and run these commands in a terminal with Codex. They add and refresh the PluginsMP catalog, then install this plugin.

Compatibility: the page URL and API slug “forge-3” remain stable.

  • Codex: forge-3@agent-plugin-marketplaceforge@agent-plugin-marketplace

The installer fetches third-party code from the source repository shown on this page. This directory validates manifest structure and source location, but does not perform a security audit; review the manifest, components, and source before installing.

Get the source manually
git clone https://github.com/gyuha/forge

Clone the source repository, then follow its setup instructions to add the plugin to a compatible client. The repository root is the plugin root.

Plugin files

forge/
├── .codex-plugin/plugin.json
├── .claude-plugin/plugin.json
├── skills/fg-adversarial-review/SKILL.md
├── skills/fg-agenda/SKILL.md
├── skills/fg-agents/SKILL.md
├── skills/fg-ask/SKILL.md
├── skills/fg-cleanup/SKILL.md
├── skills/fg-debug/SKILL.md
├── skills/fg-drop/SKILL.md
├── skills/fg-help/SKILL.md
├── skills/fg-learn/SKILL.md
├── skills/fg-loop/SKILL.md
├── skills/fg-map/SKILL.md
├── skills/fg-next/SKILL.md
├── skills/fg-quick/SKILL.md
├── skills/fg-run/SKILL.md
├── skills/fg-security/SKILL.md
├── skills/fg-status/SKILL.md
└── skills/fg-statusline/SKILL.md

Included Skills17

fg-adversarial-reviewskills/fg-adversarial-review/SKILL.md

Optional adversarial review between fg-run and fg-learn — a reviewer assumes the result is WRONG and hunts for evidence across six lenses (failure points, hidden assumptions, misread requirements, security/perf/data-loss, unexpected misuse, weak decisions), fanning out as parallel subagents; fix-needed findings become a fix-forward plan on your approval. Outside the loop, never a seal gate, always skipped in fg-next all / fg-loop. Use in contexts like 'adversarial review', '적대적 리뷰', '이 결과 공격적으로 검토', '허점 찾아줘', 'red team this'.

fg-agendaskills/fg-agenda/SKILL.md

A decision queue for foggy work — outside the forge loop. Settles the destination with you, grills breadth-first to surface what must be decided, and keeps it in .forge/agenda.md (destination · decided · open questions · fog · out of scope), resolving one question at a time via fg-ask until the way is clear, then deleting itself. The agent finds the decisions; you answer them. Use in contexts like 'forge agenda', '의제', '결정 대기열', '뭘 결정해야 하는지 정리해줘', '어디서 시작할지 모르겠다'.

fg-agentsskills/fg-agents/SKILL.md

Generates a project's domain agents — conversational grilling derives the recurring roles, then writes standard Claude Code subagent cards to .claude/agents/<role>.md (each `description` carrying a "when to use" so fg-run can dispatch a matching role as agentType). Cards load only at session start, so RESTART the session after generating them before fg-run can use them. On-demand utility outside the loop. Use in contexts like 'forge agents', '도메인 에이전트 만들어', '에이전트 팀 구성', 'create project agents', 'domain agents', 'agent roles'.

fg-askskills/fg-ask/SKILL.md

Grilling session that stress-tests your plan against the project's domain model, terminology, and documented decisions, updating CONTEXT.md/ADRs inline. The forge loop's entry point (the plan-grilling stage), always conversational. Use to start or refine a task — "start a new task", "start with forge", "let's work on this", "refine the plan", '새 작업 시작', '계획 다듬자', '이 계획 그릴링해줘'.

fg-cleanupskills/fg-cleanup/SKILL.md

Retires stale or superseded ADRs out of the active decision set — proposes candidates with rationale, and on your approval moves each to .forge/adr/retired/ (IDs never reused, nothing deleted). fg-ask stops reading retired/ as source of truth, so retired decisions drop out of grilling fuel. On-demand utility outside the loop (sealing a task is fg-done, not this). Use in contexts like 'forge cleanup', 'ADR 정리', '오래된 ADR 치워'.

fg-debugskills/fg-debug/SKILL.md

Conversational diagnosis for hard bugs and performance regressions, vendored from mattpocock/skills diagnosing-bugs. Build a red-capable loop, reproduce and minimise, rank hypotheses with the human, then instrument. Diagnosis only — an active verified failure returns to fg-run fix-and-re-run; an independent diagnosis routes a trivial fix to fg-quick or an approved non-trivial fix to a new plan. Always skipped in fg-next all / fg-loop. Use for 'debug this', 'diagnose', '디버깅해줘', '버그 잡아줘', '왜 안 되지', '왜 느리지'.

fg-dropskills/fg-drop/SKILL.md

Discards incomplete (not-yet-sealed) forge work you no longer want — backlog plans, the active slot, awaiting-retro tasks, or a halted goal loop. Presents the items with a per-item risk level, then hard-delete (default) or archive to .forge/dropped/, behind a confirmation gate (already-run code is NOT reverted). Removes forge state only — never git or your code. Outside the loop (sealing a task is fg-done). Use in contexts like 'forge drop', 'fg-drop', '작업 버리기', '계획 지워', '백로그 비워', 'discard plan'.

fg-helpskills/fg-help/SKILL.md

A read-only usage-help reporter for forge — `/forge:fg-help` prints an overview of every fg-* skill grouped by the loop's four stages plus the outside-the-loop utilities, and `/forge:fg-help <command>` a short detail (what it does · when to use · trigger · next step) for one skill. Each skill's own SKILL.md `description` is the single source, rendered in the user's language. Writes nothing, never auto-runs. Outside the loop. Use in contexts like 'forge help', 'fg-help', '도움말', '사용법', 'how do I use forge', 'what commands are there', 'fg-help fg-run'.

fg-learnskills/fg-learn/SKILL.md

After execution, classify learnings and promote them to CONTEXT.md, ADRs, evals (machine-checkable learnings promoted into the project's test suite), and the retro log (.forge/retro), then surface the next inquiry. Always conversational; respects the promotion discipline. Use to record what you learned after a task — 'forge learn', '회고하자', '이번 작업 정리해줘'.

fg-loopskills/fg-loop/SKILL.md

Goal-driven momentum loop with bounded replan — an initial conversational inquiry pins a machine-verifiable stop condition, a fix-forward scope, and a replan cap (default 3) into .forge/loop.md, then drives tasks unattended (run → UAT → auto-skip retro → seal) until the checks pass, halting only at the walls (unverifiable UAT, genuine fork, cap exhausted, no progress). On-demand orchestrator outside the loop. Use in contexts like 'forge loop', '루프 시작', '조건 충족까지 반복', 'goal loop'.

fg-mapskills/fg-map/SKILL.md

Maps the codebase with parallel subagents into structured documents under .forge/codebase/, so later grilling reads a map instead of re-exploring the code (cuts context rot). On-demand utility outside the loop. Use in contexts like "map the codebase", "analyze the codebase", "코드베이스 분석", "코드베이스 지도".

fg-nextskills/fg-next/SKILL.md

Derives the single next step of the forge loop (reusing fg-status's state machine) and runs it — announces the step, then invokes that skill (fg-status reports; fg-next acts). One-shot by default; with the 'all' argument it drives the backlog to completion, auto-skipping retros and halting at the walls (failed/unverifiable UAT, a genuine fork, empty state). The cold-re-entry entry point. Use in contexts like 'forge next', '다음 단계', '이어서 해줘', '계속 진행', 'fg-next all', '다음 전부 진행'.

fg-quickskills/fg-quick/SKILL.md

A lightweight lane outside the forge loop for trivial tasks (typo fixes, path tweaks, version bumps, small renames) — grills lightly, then runs the change directly with no formal artifacts (no ADR/plan/run/STATUS/retro). Bails to fg-ask if the task turns out non-trivial. Use in contexts like 'forge quick', '빠르게 처리', '이거 빨리 해줘', 'quick task'.

fg-runskills/fg-run/SKILL.md

Runs a refined plan (.forge/plan.md, or a waiting plan in .forge/backlog/) through the active host's execution adapter — one unexecuted plan runs right away; several show a priority-sorted selection (with 'Run all'), then the chosen task is promoted into the active slot. Warns before re-running a plan that already ran. Use in contexts like 'forge run', 'forge execute', '계획 실행', '이거 워크플로우로 돌려줘'.

fg-securityskills/fg-security/SKILL.md

Domain-specialised security audit of a codebase, outside the forge loop — a vendored multi-phase methodology (recon → parallel attack-class hunting → independent validation → machine-readable findings) whose findings, past a severity gate and your approval, become fix-forward backlog plans. Artefacts stay OUTSIDE the repo (upstream's ~/security-audit-skill/) so a vulnerability list has no path into a commit at all. Always skipped in fg-next all / fg-loop. Use in contexts like 'forge security', 'fg-security', '보안 감사', '취약점 찾아줘', 'security audit'.

fg-statusskills/fg-status/SKILL.md

A read-only status reporter for the forge loop — surveys .forge/ and shows where every task stands (active slot, backlog, awaiting-retro, done history, quick lane) plus the single next step you need, with its trigger. Writes nothing, never auto-runs (fg-status reports; fg-next acts). On-demand utility outside the loop. Use in contexts like 'forge status', '상태', '어디까지 했지', '진행 상황', 'where am I'.

fg-statuslineskills/fg-statusline/SKILL.md

Set up (or refresh) a Claude Code statusline showing forge's loop progress, in one of two modes — method 1 (append) wraps your existing statusLine as extra rows (original preserved); method 2 (merge) installs a forge-owned unified script with daleseo-style system info (model/dir/git/context/usage bars) + forge progress, with a compact/full density toggle. On-demand setup utility outside the loop. Use in contexts like 'forge statusline', 'statusline 설정', '상태바', '상태 표시줄', 'add forge to statusline'.

Plugin manifests2

.codex-plugin/plugin.json
{
  "name": "forge",
  "version": "0.9.0",
  "description": "Agent-engineering workflow skills for Claude Code, Codex, and opencode — twenty-two fg-* skills: the four-stage loop (fg-ask → fg-run → fg-learn → fg-done) plus outside-the-loop utilities, including fg-security (vendored security audit) and fg-debug (vendored diagnosis only: active failures return to fg-run; independent diagnoses route by size, durable eval, and all-exit safe cleanup).",
  "author": {
    "name": "gyuha",
    "email": "[email protected]",
    "url": "https://github.com/gyuha"
  },
  "homepage": "https://github.com/gyuha/forge",
  "repository": "https://github.com/gyuha/forge",
  "license": "MIT",
  "keywords": [
    "forge",
    "workflow",
    "planning",
    "codex",
    "claude-code"
  ],
  "skills": "./skills/",
  "interface": {
    "displayName": "Forge",
    "shortDescription": "Plan, execute, learn, and seal agent work",
    "longDescription": "A shared Claude Code and Codex workflow for turning one task into a reviewed plan, verified execution, retained learning, and a sealed result.",
    "developerName": "gyuha",
    "category": "Productivity",
    "capabilities": [
      "Interactive",
      "Write"
    ],
    "websiteURL": "https://github.com/gyuha/forge",
    "defaultPrompt": [
      "Start a new task with Forge.",
      "Show the current Forge status.",
      "Run the next Forge step."
    ],
    "brandColor": "#D97757"
  }
}
.claude-plugin/plugin.json
{
  "name": "forge",
  "description": "An agent-engineering workflow skill set (fg-*) for Claude Code. Includes fg-security, a codebase security audit (methodology vendored from cloudflare/security-audit-skill, MIT) whose artefacts stay outside the repo and whose severity-gated findings become fix-forward plans, and fg-debug, a conversational diagnosis discipline for hard bugs (vendored from mattpocock/skills' diagnosing-bugs, MIT) — diagnosis only and state-first: an active failed task returns to fg-run, while only independent diagnoses branch to fg-quick or an approved fix-forward plan; a red command counts as a persistent eval only when durable, raw captures stay outside the repo, every exit cleans temporary artefacts, and unattended drives always skip it (ADR 260907-140655). A development loop that takes one task through a single cycle of ask·plan → execute → retro → done. Consists of fg-ask (inquiry/triage + grill-with-docs-style conversational grilling), fg-run (backlog selection menu · Run all, Dynamic Workflow execution), fg-learn (retro · doc promotion · eval promotion), and fg-done (done · seal · re-run guard — the mechanical seal runs as the deterministic forge-done.sh/.js script shared by every seal path, ADR-0030), plus fg-map — an on-demand utility outside the loop that maps the codebase into .forge/codebase/ with parallel subagents so grilling reads a map instead of re-exploring the code (cuts context rot), and fg-quick — a lightweight lane outside the loop for trivial tasks that still grills lightly but skips formal artifacts (no ADR/plan/retro), records one line to .forge/quick/LOG.md, runs directly, and bails to fg-ask if the task turns out non-trivial, fg-status — a read-only reporter that surveys .forge/ and prints where every task stands plus the single next step you need (writes nothing, never auto-runs), fg-next — derives that same next step and runs it, announcing the step then invoking the skill rather than only reporting it (one-shot, except that a retro concluding without a re-grill recommendation chains straight into the seal — ADR-0026; fg-status reports, fg-next acts), with an 'all' mode (fg-next all) that drives backlog tasks to completion until empty, auto-progressing mechanical steps and halting at conversational walls, and fg-config — the unified settings surface for .forge/config.json (outside the loop), reading and writing all six keys — simple (auto-seal mode: after UAT passes, fg-run unconditionally skips the retro as retro: skipped (simple mode) and chains into the deterministic seal in the same turn; the verification gate ADR-0009 is inviolable, so verified: pending|failed is never auto-sealed), eco (economical delegated execution: fg-run caps its delegated workflow subagents at sonnet — lower only, the session model is untouched — and the embedded Eco laziness-first discipline in skills/fg-config/ECO.md (code simplicity plus terse-communication output, caveman-derived) is injected into fg-run subagents, woven into fg-ask grilling as a YAGNI lens, and adopted by the current session; eco also replaces task-end handoffs — fg-run's handoff, fg-done's explicit single seal, and the batch/unattended paths — with a compact summary table plus a per-slice table, leaving execution-time narration untouched — ADR-0014, ADR 260730-230321), tdd (a test-first default: fg-ask then defaults to asking, fg-run runs test-first — ADR-0008), driveCommit/driveCommitMessage (per-task local commit on unattended drives), and defaultBranch — replacing the former per-key toggle skills and absorbing their triggers (ADR 260905-212045), and fg-loop — a goal-driven momentum loop with bounded replan: an initial conversational inquiry pins a machine-verifiable stop condition, an authorized fix-forward replan scope, and a replan cap (default 3 rounds) into .forge/loop.md, then it drives tasks unattended (run → UAT → auto-skip retro → seal, auto-selecting recommended defaults at every soft decision and asking the user nothing) until the checks pass, generating in-scope fix-forward tasks within the cap and halting only at the walls (unverifiable UAT, genuine fork, cap exhausted, no progress, check-tension oscillation, safety/irreversible action — ADR-0016). On a non-default git branch the whole forge state moves under .forge/branch/<branch>/ (git-tracked, namespaced so parallel branches never collide on .forge state — ADR-0011), and fg-merge — an outside-the-loop utility that, after you git merge a branch (or via fg-merge <branch>, which runs that git merge for you — interactive, default branch, ADR 260717-10a), integrates that branch's .forge/branch/<branch>/ into .forge/ via the deterministic forge-merge.sh/.js script (so it also works AI-free in CI): moving time-based ADR IDs as-is with an exact-ID clash taking the next free letter (no cascade renumber), merging CONTEXT terms, folding done history, removing the branch folder; it halts non-zero on genuine conflicts (a redefined term, an incoming NNNN collision), leaving semantic ADR contradictions to PR review, and fg-cleanup — an outside-the-loop utility that retires stale or superseded ADRs to .forge/adr/retired/ on your approval, keeping the active decision set current without deleting the why (ADR-0012), and fg-statusline — an outside-the-loop setup utility that shows the current loop progress in your terminal statusline in one of two modes: append (method 1) auto-wraps your existing statusLine so forge shows as an extra row rather than replacing it (ADR-0017), or merge (method 2) installs a forge-owned unified script rendering daleseo-style system info (model·effort·dir·git, plus context/usage/weekly usage bars) alongside forge progress in one command (ADR-0029), and fg-adversarial-review — an outside-the-loop utility that runs an optional adversarial review between fg-run and fg-learn: it assumes the result is wrong and fans out six lenses (failure points, hidden assumptions, misread requirements, security/performance/data-loss, unexpected misuse, weak decisions) as parallel workflow subagents, records findings to .forge/review.md, and on your approval turns fix-needed findings into a fix-forward plan to run again — optional, never a seal gate, always auto-skipped in unattended drives (ADR-0018), and fg-doctor — a read-only integrity health check (outside the loop) that surveys the .forge/ state contract and the docs/manifests and reports inconsistencies with a severity and an actionable fix hint each (orphaned run.md, broken/missing STATUS fields, slug-pairing mismatches, half-sealed done/, an orphaned branch root you forgot to fg-merge, manifest version drift across the 3 places, README bilingual drift, skills missing from CLAUDE.md), now script-backed by forge-doctor.sh/.js and usable AI-free as a CI gate; it writes nothing and never auto-fixes — fg-status reports where you are, fg-doctor reports whether the state is healthy (ADR-0019), and fg-help — a read-only usage-help reporter outside the loop: /forge:fg-help prints an overview of every forge fg-* skill grouped by the loop's four stages plus the outside-the-loop utilities, and /forge:fg-help <command> prints a short 4-line usage detail (what it does · when to use · trigger · next step) for one skill; it reads each skill's own SKILL.md description as the single source (no copied usage text, so a new skill shows up automatically) and renders the output in the user's language at runtime, so it is LLM-executed with no deterministic script twin — the translation is why it differs from fg-status/fg-doctor; it writes nothing and never auto-runs (fg-status: where am I, fg-doctor: is the state healthy, fg-help: how do I use these) (ADR 260814-104534), and fg-drop — an outside-the-loop utility that discards incomplete work you no longer want (a backlog plan, the active slot, an awaiting-retro task in executed/, or a halted goal loop): it lists the items with a per-item risk level (a checkbox dialog for ≤4, a numbered text list for ≥5), then a separate question to hard-delete (default, no trace) or archive to .forge/dropped/, behind a confirmation gate that warns already-run code is not reverted; it removes forge state only — never git, never your code — and a halted goal loop is dropped whole with its member tasks excluded from individual drop (ADR-0021), and fg-agents — an outside-the-loop utility that generates a project's domain agents by conversational grilling (outside any workflow): it derives the recurring, separable roles in the project and writes standard Claude Code subagent cards to .claude/agents/<role>.md, each description carrying a 'when to use' so fg-run can dispatch a matching role as agentType; the cards load at session start so they take effect only after a restart, and the whole path is graceful — a project with no domain agents runs exactly as before (ADR-0024), and fg-showme — an outside-the-loop utility that opens a browser-based visual companion in any conversation (vendored from obra/superpowers v6.1.1's Visual Companion with MIT attribution): a zero-dependency local Node server (scripts/server.cjs plus 4 companion files) shows mockups, diagrams, and visual A/B options the agent pushes as HTML in a live browser tab and takes the user's answers back as JSONL events — a click settles a choice and a screen can carry a text box — which the agent reads back; session files live under the top-level .forge/showme/<session>/ on every branch (volatile, gitignored — a global exception like config.json and codebase/, never the branch root), with session-key URL auth, restart/reconnect survival, a 4-hour idle auto-shutdown, and no telemetry or remote assets; during fg-ask grilling the companion is offered once just-in-time at the first visual question (a standalone message, never re-offered after a decline), fg-ask consuming ../fg-showme/VISUAL.md and scripts/ by file reference (the single-definition convention) and shutting the server down at handoff, while this skill is the standalone entry point (fg-showme to start, fg-showme stop to shut down) (ADR 260719-224442), and fg-agenda — an outside-the-loop planning utility that gives forge a home for a decision not yet made: everything else forge produces is a build artifact and an ADR records a decision already made, so work still in fog either gets forced into a prematurely-complete plan or its open decisions scatter across conversation and retro prose and vanish; fg-agenda settles the destination with you, grills breadth-first to surface what must be decided, and keeps one file .forge/agenda.md (destination · decided · open questions · fog · out of scope), resolving one question at a time by fg-ask's grilling method until the way is clear and then deleting itself, the durable trace being the ADRs and backlog plans it produced — the agent finds what must be decided and the human answers every question (it never answers its own), a decision that becomes buildable leaves the agenda to be an ordinary backlog plan through fg-ask so the agenda is never a second backlog, and it stays out of the fg-next/fg-status next-step chain (fg-status reports a present agenda in one line); adapted in concept, not code, from the Wayfinder skill in mattpocock/skills (MIT) (ADR 260805-201313). Beyond the skills, the plugin ships one hook (auto-discovered hooks/hooks.json — installed with the plugin, no settings.json edit): at SessionStart (startup/resume/clear/compact) it injects a short notice when, and only when, an unsealed tail exists — a task that ran but was never sealed, a task parked awaiting retro, or a halted goal loop — so the agent surfaces it before any new work starts; it never auto-runs and never auto-seals (the decision stays the user's), stays completely silent on a clean repo or a backlog-only queue, dispatches through a bash-then-node polyglot wrapper that exits silently when neither runtime exists, and — because hooks load at session start — applies from the NEXT session (ADR 260727-201031). Use in contexts like 'start a new task', 'start with forge', 'let's work on this', 'refine the plan', 'map the codebase', 'forge quick', 'forge status', 'forge next', 'forge loop', 'forge config', '설정', 'simple mode', 'eco on', 'tdd on', 'forge merge', 'forge cleanup', 'forge statusline', 'adversarial review', '적대적 리뷰', 'forge doctor', '무결성 검사', '상태 점검', 'forge drop', '작업 버리기', '계획 지워', 'forge agents', '도메인 에이전트 만들어', 'create project agents', 'forge visual', 'visual companion', '목업 보여줘', 'forge agenda', '의제', '결정 대기열', 'forge help', 'fg-help', '도움말', '사용법', 'debug this', '디버깅해줘', '버그 잡아줘', 'hunt this bug'.",
  "version": "0.9.0",
  "author": {
    "name": "gyuha",
    "email": "[email protected]",
    "url": "https://github.com/gyuha"
  },
  "homepage": "https://github.com/gyuha/forge",
  "repository": "https://github.com/gyuha/forge",
  "license": "MIT",
  "keywords": [
    "forge",
    "workflow",
    "loop",
    "grill-with-docs",
    "planning",
    "retrospective",
    "claude-code"
  ]
}

If you maintain this plugin, link to this source-backed listing from your README so users can review its manifest and indexed components.

[forge on Agent Plugins Marketplace](https://pluginsmp.com/plugins/forge-3)