forgedock 1.0.9 → 1.0.11

package/docs/anthropic-devrel-outreach.md

@@ -0,0 +1,197 @@
+# Anthropic DevRel Outreach — ForgeDock
+
+Campaign playbook for getting ForgeDock featured in the Claude Code ecosystem. Execute each channel in order; update the tracking table after each action.
+
+---
+
+## Assets Ready
+
+These assets are live and can be referenced in any outreach:
+
+| Asset | Link | Status |
+|-------|------|--------|
+| GitHub repository | https://github.com/RapierCraftStudios/ForgeDock | ✅ Live |
+| npm package | https://www.npmjs.com/package/forgedock | ✅ Live |
+| Plugin marketplace listing | https://github.com/dev-gom/claude-code-marketplace | ✅ Submitted (#541) |
+| Demo GIF | `docs/demo.tape` (generated asset) | ✅ Ready (#542) |
+| FORGE Annotation Protocol spec | `docs/FORGE-PROTOCOL.md` | ✅ Published (#553) |
+| dev.to article | `docs/articles/devto-how-i-built-an-ai-agent-that-never-forgets.md` | ✅ Draft ready (#549) |
+| Awesome list submissions | `docs/distribution-submissions.md` | ✅ Documented (#552) |
+
+---
+
+## Canonical Pitch (3 sentences)
+
+> ForgeDock is an autonomous development pipeline for Claude Code that uses GitHub as a persistent knowledge graph. Every pipeline stage (investigate → architect → build → review → merge) writes structured FORGE annotations to GitHub issues and PRs — so agents always know what happened before them, why the code looks the way it does, and what to do next. Install in seconds: `npx forgedock`, then run `/work-on #42`.
+
+---
+
+## Channel 1: Direct Email to Anthropic DevRel
+
+**Target**: Alex Albert (leads Claude Code), Anthropic DevRel team
+**Contact path**: Twitter/X DM (`@alexalbert__`), or via Anthropic's developer contact form at https://www.anthropic.com/contact
+**Goal**: Get featured in Claude Code official docs community section, or secure a case study / guest blog post opportunity
+
+### Email / DM Template
+
+**Subject**: ForgeDock — Claude Code pipeline that demos what the command system can fully do
+
+---
+
+Hi Alex,
+
+I built ForgeDock — an autonomous development pipeline for Claude Code that uses GitHub as a persistent knowledge graph for AI agents.
+
+**What it does**: Install with `npx forgedock`, then type `/work-on #42`. Claude Code investigates the issue, writes an architecture plan, implements the fix, runs a quality gate, opens a PR, reviews it with specialized agents, and merges — all autonomously. Every stage writes structured FORGE annotations back to GitHub so the next agent picks up exactly where the previous one left off. No context loss between sessions.
+
+**Why it might interest you**:
+- It's a showcase of what Claude Code's command system can do at full depth — 25+ commands, multi-agent coordination, GitHub-as-knowledge-graph
+- It's already being used on production codebases (dogfood: ForgeDock's own issues are built by ForgeDock)
+- I published a formal FORGE Annotation Protocol spec (open standard for AI agent communication via GitHub)
+
+**What I'm asking for**:
+- If there's a community tools / ecosystem section in the Claude Code docs, I'd love ForgeDock listed there
+- Happy to write a guest blog post, be a case study, or demo it for the team — whatever's useful
+
+GitHub: https://github.com/RapierCraftStudios/ForgeDock
+npm: https://www.npmjs.com/package/forgedock
+
+Thanks for building Claude Code — it's genuinely the best AI dev tool I've used.
+
+[Your name]
+
+---
+
+**Send via**: Twitter/X DM to `@alexalbert__` is the most direct path. Anthropic's contact form is the backup.
+
+---
+
+## Channel 2: Anthropic Discord
+
+**Target**: Anthropic's official Discord server — Claude Code channels
+**Goal**: Build genuine community presence; get noticed by Anthropic staff who monitor their own Discord
+**Discord**: https://discord.gg/anthropic (official) — look for `#claude-code`, `#show-your-work`, or `#developer-tools` channels
+
+### Discord Message Script
+
+**For `#show-your-work` or `#claude-code` channel**:
+
+---
+
+Hey everyone — I built something I think you'll find useful if you're using Claude Code heavily.
+
+**ForgeDock** — autonomous dev pipeline for Claude Code that uses GitHub as a persistent knowledge graph.
+
+The core idea: AI agents forget everything between sessions. ForgeDock fixes that by having every pipeline stage write structured FORGE annotations to GitHub issues and PRs. The next agent (even in a new session) reads those annotations and picks up exactly where the last one left off.
+
+**In practice**: type `/work-on #42`, Claude Code:
+1. Investigates the issue (reads git blame, past bugs, related PRs)
+2. Writes an architecture plan
+3. Implements the fix
+4. Runs a quality gate
+5. Opens a PR and reviews it with specialized agents
+6. Merges
+
+Install: `npx forgedock`
+GitHub: https://github.com/RapierCraftStudios/ForgeDock
+
+Happy to answer questions or demo it. Built 100% with Claude Code — ForgeDock builds itself. 🔁
+
+---
+
+**Engagement tips**:
+- Reply genuinely to questions in the thread
+- If others share Claude Code workflows, engage with value before sharing ForgeDock
+- Do NOT post the same message in multiple channels the same day — pick one channel, post once, engage for 48h before other channels
+
+---
+
+## Channel 3: Claude Code Docs Listing
+
+**Target**: https://docs.anthropic.com/en/docs/claude-code — community resources / ecosystem section
+**Goal**: Get ForgeDock listed as a community tool in the official Claude Code documentation
+
+### Submission Approach
+
+Anthropic's docs are maintained at https://github.com/anthropics/anthropic-sdk-python (API docs) but Claude Code docs may be at a separate repo. Check:
+1. https://github.com/anthropics/claude-code (if public)
+2. https://github.com/anthropics/anthropic-quickstarts
+3. Contact via DevRel (Channel 1) and ask where to submit community tool PRs
+
+### Formatted Listing Entry
+
+Use this in a PR or suggestion:
+
+```markdown
+### ForgeDock
+[ForgeDock](https://github.com/RapierCraftStudios/ForgeDock) — Autonomous development pipeline for Claude Code. Uses GitHub as a persistent knowledge graph: agents investigate, architect, build, quality-gate, review, and merge with full context persistence across sessions. Install: `npx forgedock`.
+```
+
+**Category to target**: Community Tools / Extensions / Third-party integrations
+
+---
+
+## Channel 4: Twitter/X Mention
+
+**Target**: `@AnthropicAI` and `@alexalbert__`
+**Goal**: Public mention that prompts engagement or retweet from official accounts
+
+### Tweet Template
+
+```
+I built an autonomous dev pipeline for @ClaudeAI Code that uses GitHub as a persistent knowledge graph for AI agents.
+
+Every agent in the pipeline reads what came before it — investigation findings, architecture decisions, past bugs — so nothing gets lost between sessions.
+
+25+ commands. Full investigate → build → review → merge cycle.
+
+npx forgedock
+
+github.com/RapierCraftStudios/ForgeDock
+
+@alexalbert__ would love your thoughts on using it as a Claude Code case study 🙏
+```
+
+**Post timing**: Post after Anthropic Discord engagement (Channel 2) — social proof from Discord replies strengthens the tweet.
+
+---
+
+## Tracking Table
+
+| Channel | Action | Status | Date | Follow-up Due | Notes |
+|---------|--------|--------|------|---------------|-------|
+| Direct email / DM | Send to @alexalbert__ | ⬜ Not sent | — | — | |
+| Anthropic Discord | Post in Claude Code channel | ⬜ Not posted | — | — | |
+| Claude Code docs | Submit PR or suggestion | ⬜ Not submitted | — | — | Find correct repo first |
+| Twitter/X | Tweet mentioning @alexalbert__ | ⬜ Not posted | — | — | Post after Discord |
+
+---
+
+## Follow-up Cadence
+
+After each initial outreach action:
+
+| Timing | Action |
+|--------|--------|
+| Day 0 | Send initial outreach (email DM / Discord post) |
+| Day 7 | If no response to DM: send one follow-up. If Discord post got engagement: reply to any threads. |
+| Day 14 | If still no response: move to async — submit Claude Code docs PR directly without waiting for DevRel response |
+| Day 30 | Reassess. If featured: document in this file. If not: try Anthropic contact form with a different angle (FORGE Protocol as open standard). |
+
+---
+
+## Success Criteria
+
+- [ ] Outreach email/DM sent to Anthropic DevRel — update tracking table
+- [ ] ForgeDock shared in Anthropic Discord — update tracking table
+- [ ] PR/suggestion submitted for Claude Code docs listing — update tracking table
+- [ ] Follow-up within 1 week if no response — update tracking table
+
+---
+
+## Related Assets
+
+- `docs/distribution-submissions.md` — canonical description + awesome list submissions
+- `docs/FORGE-PROTOCOL.md` — FORGE Annotation Protocol spec (shareable with Anthropic as ecosystem contribution)
+- `docs/articles/devto-how-i-built-an-ai-agent-that-never-forgets.md` — long-form story for blog pitch
+- `docs/youtube-demo-script.md` — demo video script (reference for pitch)

package/docs/articles/devto-how-i-built-an-ai-agent-that-never-forgets.md

@@ -0,0 +1,165 @@
+---
+title: "How I Built an AI Agent That Never Forgets"
+description: "AI coding agents forget everything between sessions. Here's how I used GitHub as a knowledge graph to give them persistent, structured memory — and the surprising insight that made it work."
+tags: ["ai", "github", "productivity", "opensource"]
+cover_image: # Add social preview image URL (see issue #543)
+canonical_url: https://github.com/RapierCraftStudios/ForgeDock
+published: false
+---
+
+<!-- DEMO GIF PLACEHOLDER: Insert demo GIF here once issue #542 is complete -->
+<!-- Suggested: zero-to-PR speedrun showing /work-on running the full pipeline -->
+
+I've been running AI coding agents on production codebases for about a year. The workflow is genuinely useful — but there's a problem that kept surfacing no matter which model or tool I used.
+
+Every session starts from scratch.
+
+---
+
+## The Problem
+
+My agent doesn't know what it fixed yesterday. It doesn't know that the function it's about to touch was shaped by a nasty race condition discovered in PR #891 six months ago. It doesn't know that three other files use the same pattern and will need the same fix. It doesn't know that the last time someone tried this approach, it caused a production incident for a specific class of users.
+
+Context window isn't the bottleneck. **Memory is.**
+
+When a conversation ends or a context compaction happens, everything the agent learned — every hypothesis it tested, every file it read, every connection it made — is gone. The next agent starts from a blank slate. The investigation gets repeated. The same mistakes get made. There's no institutional knowledge.
+
+This isn't an AI limitation. It's a systems design problem. And once I framed it that way, the solution became obvious.
+
+---
+
+## The Failed Approaches
+
+I tried the obvious fixes first.
+
+**Long CLAUDE.md files** — I kept adding to my project instructions until they were 3,000 words of context. It helped with conventions but didn't solve the knowledge gap. CLAUDE.md is static. It doesn't know which specific files have been touched, what bugs were found in module X last week, or what architectural decision was made in PR #342 and why. It's a README for the agent, not a memory system.
+
+**Massive context windows** — Just feeding the agent more files to read. This works for small, well-scoped tasks. It breaks down at scale: too much noise, too many tokens, and still no ability to recall *prior decisions* made by *prior agents*. A 200k token context window doesn't help you remember what you decided three sessions ago if that decision isn't written down somewhere the next agent will read.
+
+**RAG over the codebase** — Vector databases of code snippets. Better than nothing, but it retrieves *what the code looks like*, not *why it looks that way*. The investigative context — the root cause analysis, the rejected approaches, the cross-file impact assessment — isn't in the code. It's in the conversation that led to the code. And that conversation disappeared when the session ended.
+
+---
+
+## The Insight
+
+Here's the thing I kept overlooking: GitHub already stores everything an agent needs to know.
+
+Issues document what went wrong and why. Pull requests record what changed and link back to the issue that prompted it. Commit messages reference both. `git blame` traces any line of code back to the PR that introduced it, and from there to the issue that motivated it. Cross-references are built in.
+
+GitHub is already a knowledge graph. It's just not structured for AI agents to query efficiently.
+
+The insight that changed everything: **make the knowledge machine-readable at write time.** Instead of having agents try to parse human-written issue comments after the fact, have every pipeline stage write structured, machine-readable annotations *as it works*. Then the next agent — in the next session, on a completely different task — can query those annotations and get exactly the structured context it needs.
+
+Not "read all the comments and figure it out." Read `<!-- FORGE:INVESTIGATOR -->` and get a structured JSON-like summary: affected files, root cause, confidence level, recommendation. Read `<!-- FORGE:CONTEXT -->` and get the pitfalls found in prior review findings for those same files.
+
+---
+
+## The Implementation
+
+I built a system called ForgeDock. At its core, it's a pipeline of Claude Code slash commands that coordinate through GitHub using structured HTML comment annotations.
+
+Here's what it looks like in practice:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                     GITHUB (Knowledge Graph)                        │
+│                                                                     │
+│  Issues:  FORGE:INVESTIGATOR → FORGE:CONTRACT → FORGE:ARCHITECT     │
+│  PRs:     FORGE:BUILDER → FORGE:REVIEW → FORGE:TRAJECTORY           │
+│  Links:   git blame → commit → PR → issue → related issues          │
+│                                                                     │
+│  Every agent reads this. Every agent writes to it.                  │
+│  Nothing is lost between conversations.                             │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+When you run `/work-on #42`, the pipeline stages execute in sequence. Each stage writes a structured annotation to the GitHub issue before the next stage starts.
+
+**FORGE:INVESTIGATOR** — The investigation agent reads the codebase, verifies the claim in the issue, traces the root cause to specific files and commits, and writes a structured report:
+
+```
+<!-- FORGE:INVESTIGATOR -->
+**Verdict**: CONFIRMED
+**Confidence**: HIGH
+**Root Cause**: payment_validator.py:143 assumes all users have a billing profile.
+                Free-tier users don't. Introduced in commit e8f21a3 (PR #38).
+**Affected Files**: payment_validator.py, api/routes/payments.py
+**Recommendation**: Add nil-check before billing profile access.
+```
+
+**FORGE:CONTEXT** — Before the builder writes a single line of code, a context agent queries GitHub for institutional memory: past review findings on those specific files, prior bugs in the same module, related PRs that touched the same functions. It surfaces this as a structured advisory:
+
+```
+<!-- FORGE:CONTEXT -->
+**Known Pitfall**: Don't skip the audit log write on early returns in this module.
+                   Prior bug #34 did exactly this and caused a compliance gap.
+**Historical Finding**: Free-tier guard was also missing in invoices.py (#43) —
+                        check for the same pattern there.
+```
+
+The builder agent reads this context before writing code. It doesn't re-discover known pitfalls. It doesn't repeat mistakes that were fixed six months ago.
+
+**FORGE:ARCHITECT** — An architecture agent traces all affected code paths, builds an ordered implementation plan, and identifies consistency invariants. The builder follows this plan exactly, in order.
+
+**FORGE:BUILDER** — The implementation agent works in a git worktree, reads the full context chain, implements the fix, runs quality gates, and commits.
+
+**FORGE:TRAJECTORY** — After the PR merges, a trajectory entry is written to the issue recording the full pipeline result: investigation verdict, quality gate result, review findings, merge details. Future context agents read this when working on related issues.
+
+The key principle: **every agent writes what it learned, so the next agent doesn't have to rediscover it.**
+
+---
+
+## Results
+
+Here's a concrete before/after.
+
+**Before ForgeDock:** An agent gets issue #47 — "Billing fails for users who signed up before the subscription migration." The agent reads the codebase, explores billing-related files, eventually finds the inconsistency in the subscription lookup logic. Takes 15-20 minutes of investigation. Misses the fact that the same pattern exists in the invoices endpoint too. Fix is incomplete. Review catches it. Another iteration.
+
+**After ForgeDock:** The context agent queries GitHub for past bugs in the billing module. It finds FORGE:TRAJECTORY from issue #38 (payment nil-check fix) and #43 (invoices nil-check fix). The investigation comment from #43 explicitly noted: "same nil-check pattern also exists in subscriptions.py — not fixed in this PR, tracked as follow-up." That follow-up is issue #47.
+
+The agent already knows: the root cause is a nil-check pattern that was incompletely applied across three files. It knows which files. It knows which commit introduced the pattern. It knows what the fix looks like — it was already implemented correctly in two other files. Investigation takes 3 minutes. Implementation is straightforward. Review passes first time.
+
+Another example: I was working on a feature to add rate limiting to the API. The context agent surfaced a review finding from PR #91 — "Rate limiting middleware must be applied before the auth middleware, not after — see the ordering note in middleware.md." That finding was written by a review agent eight months ago on a completely different PR. It saved me from introducing an ordering bug that would have bypassed auth for rate-limited requests.
+
+The system gets smarter over time because the knowledge compounds. Every fix, every review finding, every architectural decision becomes queryable structured data for future agents.
+
+There's a subtler benefit too: **the pipeline makes agents deterministic.** Without structured context, agents make different decisions on the same problem depending on which files they happen to read first and what associations their current session happens to surface. With ForgeDock, every agent working on related issues reads the same FORGE annotations. They make consistent decisions because they're working from the same structured data, not from vibes.
+
+The review layer adds another dimension. ForgeDock's `/review-pr` command runs nine specialized review agents against every PR — each focused on a specific domain: concurrency, auth, SQL safety, frontend proxy wiring, deployment completeness, and so on. Each agent's findings become new GitHub issues, which flow through the same pipeline. Over time, the review agents get better at catching the specific bug classes that have appeared in your codebase before, because those patterns are recorded as structured findings in GitHub. The same nil-check pattern that caused a bug in the billing module will be caught by the context agent when someone touches the invoices module two months later.
+
+It's not magic. It's just structured data, written consistently, read reliably.
+
+---
+
+## Try It
+
+ForgeDock is open source and installs in two commands:
+
+```bash
+# Step 1: Install pipeline commands
+npx forgedock
+
+# Step 2: Generate config for your repo
+npx forgedock init
+```
+
+`npx forgedock init` auto-detects your repo, owner, and branches, and creates a `forge.yaml` config file. Then inside Claude Code:
+
+```
+/work-on #42
+```
+
+That's it. The pipeline runs: investigate → build → quality gate → PR creation → review → merge.
+
+The full source is at [github.com/RapierCraftStudios/ForgeDock](https://github.com/RapierCraftStudios/ForgeDock). AGPL-3.0 — free to use, modify, and self-host. If you build on it or extend it, open your modifications.
+
+---
+
+*Tags: #ai #github #productivity #opensource*
+
+---
+
+**Cross-post notes:**
+- Hashnode: Same content, update canonical_url to point to dev.to post after publishing
+- Medium: Publish after dev.to if reach warrants (dev.to SEO compounds faster)
+- Optimal publish time: Tuesday-Thursday 9-10am ET for dev.to algorithm

package/docs/demo.tape

@@ -0,0 +1,113 @@
+# ForgeDock Demo — Zero to PR Speedrun
+# Generates: docs/demo.gif
+#
+# Requirements: https://github.com/charmbracelet/vhs
+# Usage:        vhs docs/demo.tape
+#
+# Shows the full /work-on pipeline:
+#   1. File a GitHub issue
+#   2. Run /work-on — agent investigates, architects, builds, and opens a PR
+#
+# Target: under 30 seconds, under 5MB
+
+Output docs/demo.gif
+
+Set FontSize 14
+Set Width 1200
+Set Height 650
+Set Theme "Dracula"
+Set TypingSpeed 60ms
+Set PlaybackSpeed 1.0
+
+# ── Step 1: Set the scene ─────────────────────────────────────────────────────
+
+Type "# Zero to PR — ForgeDock speedrun"
+Sleep 800ms
+Enter
+
+Sleep 400ms
+
+# Show the issue we're working on
+Type "gh issue view 42 -R your-org/your-repo --json title,body | jq -r '.title'"
+Sleep 400ms
+Enter
+Sleep 1s
+
+# ── Step 2: Launch Claude Code and invoke /work-on ───────────────────────────
+
+Type "claude"
+Sleep 400ms
+Enter
+Sleep 2s
+
+Type "/work-on 42"
+Sleep 400ms
+Enter
+Sleep 1.5s
+
+# ── Step 3: Investigation phase ──────────────────────────────────────────────
+# Agent reads the issue, searches the codebase, traces root cause
+
+Sleep 500ms
+Type "# Agent: Reading issue #42 → tracing root cause..."
+Enter
+Sleep 1s
+
+# Simulate the agent reading files (fast-forward)
+Sleep 800ms
+Type "# [Investigation] Confirmed: nil-check missing in payment_validator.py:87"
+Enter
+Sleep 1s
+
+# ── Step 4: Context + Architect phase ────────────────────────────────────────
+# Agent reads historical findings, builds implementation plan
+
+Type "# [Context] Found 2 historical bugs in this module (issues #29, #34)"
+Enter
+Sleep 800ms
+
+Type "# [Architect] Implementation order: validator → router → tests"
+Enter
+Sleep 1s
+
+# ── Step 5: Build phase ───────────────────────────────────────────────────────
+# Agent writes the code
+
+Type "# [Build] Writing fix to payment_validator.py..."
+Enter
+Sleep 1s
+
+Type "git diff --stat"
+Sleep 400ms
+Enter
+Sleep 1.2s
+
+Type "git log --oneline -3"
+Sleep 400ms
+Enter
+Sleep 800ms
+
+# ── Step 6: PR opened ────────────────────────────────────────────────────────
+
+Type "# [Review] Opening PR → /review-pr #107 --auto-merge"
+Enter
+Sleep 1s
+
+Type "gh pr view 107 --json title,state | jq -r '\"PR: \" + .title + \" (\" + .state + \")\"'"
+Sleep 400ms
+Enter
+Sleep 1.2s
+
+# ── Step 7: Done ─────────────────────────────────────────────────────────────
+
+Type "# Done. Issue → Investigation → Build → PR in one command."
+Enter
+Sleep 1.5s
+
+Type "gh issue view 42 --json labels --jq '[.labels[].name]'"
+Sleep 400ms
+Enter
+Sleep 1.5s
+
+# Final pause before loop
+Sleep 1s

package/docs/distribution-submissions.md

@@ -0,0 +1,181 @@
+# ForgeDock Distribution Submissions
+
+Submission tracker and content playbook for awesome list and community marketplace listings.
+
+---
+
+## Canonical Description
+
+Use this across all submissions (≤150 chars):
+
+> **ForgeDock** — Autonomous AI dev pipeline for Claude Code. Uses GitHub issues/PRs as a structured knowledge graph so agents never lose context between sessions.
+
+Long form (for platforms that allow more):
+
+> ForgeDock turns GitHub into a persistent knowledge graph for Claude Code agents. Every pipeline stage (investigate → architect → build → review → merge) writes structured annotations to GitHub issues and PRs — so agents always know what happened before them, why the code looks the way it does, and what to do next. Install with `npx forgedock` and run `/work-on #42`.
+
+**Links**:
+- GitHub: https://github.com/RapierCraftStudios/ForgeDock
+- npm: https://www.npmjs.com/package/forgedock
+- License: AGPL-3.0
+
+---
+
+## Awesome List Submissions
+
+### 1. awesome-claude-code-workflows
+
+| Field | Value |
+|-------|-------|
+| **URL** | https://github.com/ithiria894/awesome-claude-code-workflows |
+| **Category** | Workflow Automation / Pipeline Orchestration |
+| **Status** | ⬜ Not submitted |
+| **PR** | — |
+
+**Submission format** (follow repo's CONTRIBUTING.md exactly):
+```markdown
+- [ForgeDock](https://github.com/RapierCraftStudios/ForgeDock) — Autonomous dev pipeline that uses GitHub as a structured knowledge graph. Agents investigate → architect → build → review → merge with full context persistence across sessions.
+```
+
+---
+
+### 2. claude-code-marketplace
+
+| Field | Value |
+|-------|-------|
+| **URL** | https://github.com/dev-gom/claude-code-marketplace |
+| **Category** | Development Pipeline / AI Agents |
+| **Status** | ⬜ Not submitted |
+| **PR** | — |
+
+**Submission format** (follow repo's CONTRIBUTING.md exactly):
+```markdown
+- [ForgeDock](https://github.com/RapierCraftStudios/ForgeDock) — `npx forgedock` — Autonomous AI dev pipeline for Claude Code. GitHub-as-knowledge-graph keeps agents context-aware across investigate → build → review → merge cycles.
+```
+
+---
+
+### 3. awesome-ai-agents
+
+Search for the highest-authority list in this space:
+- https://github.com/e2b-dev/awesome-ai-agents
+- https://github.com/slavakurilyak/awesome-ai-agents
+- https://github.com/Jenqyang/Awesome-AI-Agents
+
+| Field | Value |
+|-------|-------|
+| **Target** | Identify highest-star repo in category |
+| **Category** | Developer Tools / Coding Agents |
+| **Status** | ⬜ Not submitted |
+| **PR** | — |
+
+**Submission format**:
+```markdown
+- [ForgeDock](https://github.com/RapierCraftStudios/ForgeDock) — Autonomous development pipeline for Claude Code that uses GitHub as a persistent knowledge graph. Provides investigate → architect → build → quality-gate → review → merge pipeline with structured context annotations that survive agent compaction and session boundaries.
+```
+
+---
+
+### 4. awesome-developer-tools
+
+Search for the highest-authority list in this space:
+- https://github.com/marcobiedermann/awesome-developer-tools (if active)
+- Search GitHub for `awesome developer tools` sorted by stars
+
+| Field | Value |
+|-------|-------|
+| **Target** | Identify highest-star repo in category |
+| **Category** | AI / Automation / CLI Tools |
+| **Status** | ⬜ Not submitted |
+| **PR** | — |
+
+**Submission format**:
+```markdown
+- [ForgeDock](https://github.com/RapierCraftStudios/ForgeDock) — Autonomous AI coding pipeline for Claude Code. Turns GitHub into a structured knowledge graph so agents never lose context between sessions. Install: `npx forgedock`.
+```
+
+---
+
+### 5. Additional High-Value Lists (bonus)
+
+| List | URL | Status |
+|------|-----|--------|
+| awesome-claude | Search GitHub | ⬜ Not submitted |
+| awesome-llm-apps | https://github.com/Shubhamsaboo/awesome-llm-apps | ⬜ Not submitted |
+| awesome-ai-tools | Various — search by stars | ⬜ Not submitted |
+
+---
+
+## Community Marketplaces
+
+### Product Hunt
+
+| Field | Value |
+|-------|-------|
+| **Status** | ⬜ Not submitted |
+| **URL** | https://www.producthunt.com/posts/new |
+| **Launch type** | Full product launch (not just a listing) |
+
+**Submission checklist**:
+- [ ] Schedule for a Tuesday or Wednesday (highest traffic days)
+- [ ] Prepare a 60-second demo GIF (blocked on #542)
+- [ ] Write tagline: "Autonomous AI dev pipeline — GitHub as a knowledge graph for Claude Code agents"
+- [ ] Prepare 3–5 screenshots or a demo video
+- [ ] List alternatives: Sweep, GitHub Copilot Workspace, Devin, Cursor Agent
+- [ ] Have 10+ upvote supporters lined up before launch
+- [ ] Post in relevant PH collections: Developer Tools, AI Tools, CLI Tools
+
+**Product Hunt description**:
+```
+ForgeDock gives Claude Code agents persistent memory across sessions by using GitHub as a structured knowledge graph.
+
+Every pipeline stage (investigate → architect → build → review → merge) writes structured FORGE: annotations to GitHub issues and PRs. Agents read what came before them. Nothing is lost between conversations.
+
+Install with `npx forgedock` → run `/work-on #42` → watch it investigate, architect, build, quality-gate, and open a PR.
+```
+
+---
+
+### AlternativeTo
+
+| Field | Value |
+|-------|-------|
+| **Status** | ⬜ Not submitted |
+| **URL** | https://alternativeto.net/software/add |
+| **Alternatives to list** | Sweep, Devin, GitHub Copilot Workspace, Cursor Agent, Aider |
+
+**AlternativeTo description**:
+```
+ForgeDock is an autonomous AI development pipeline for Claude Code that uses GitHub as a persistent knowledge graph.
+
+Unlike Sweep or Devin which start fresh each session, ForgeDock stores structured context in GitHub issue comments (FORGE: annotations) so every agent knows the investigation history, architecture decisions, and past bugs for the code it's touching.
+
+Install: npx forgedock. Commands: /work-on, /review-pr, /quality-gate, /orchestrate.
+```
+
+---
+
+## Submission Guidelines (General)
+
+1. **Follow each repo's CONTRIBUTING.md** — most awesome lists have specific format requirements
+2. **Alphabetical order** — most lists are alphabetically sorted; find the correct position
+3. **One PR per list** — do not batch submissions
+4. **Description length** — most lists cap at 120–150 chars; use the canonical short description
+5. **No self-promotional language** — "the best", "revolutionary", "amazing" are red flags
+6. **Include the category** — verify the correct section before submitting
+7. **Check for duplicates** — search the list for "forgedock", "claude-code", "forge" before PRing
+
+---
+
+## Status Summary
+
+| Platform | Type | Status | PR/URL |
+|----------|------|--------|--------|
+| awesome-claude-code-workflows | Awesome list | ⬜ Not submitted | — |
+| claude-code-marketplace | Marketplace | ⬜ Not submitted | — |
+| awesome-ai-agents | Awesome list | ⬜ Not submitted | — |
+| awesome-developer-tools | Awesome list | ⬜ Not submitted | — |
+| Product Hunt | Community platform | ⬜ Not submitted | — |
+| AlternativeTo | Directory | ⬜ Not submitted | — |
+
+**Update this table as submissions are made. Mark with ✅ when PR is merged or listing is live.**