dev-loop: merge loop-orchestrator + dev-llm-wiki into one plugin

Fork of loop-orchestrator with the plan step FIXED to the bundled wiki-plan
methodology (mandatory, wiki-grounded) instead of an optional pluggable role.
The rest of the verification loop (TDD / PDCA / Reflexion) is unchanged.

- Bundles the dev-llm-wiki semantic-layer wiki (wiki/, INDEX.md, AGENTS.md,
  templates/, log.md) + its wiki-plan/implement/ingest/query/lint skills.
- loop-implement step 2 now hardwires wiki-plan; the `plan` capability role is
  removed from resolve-tools / tool-profile / examples.
- Knowledge-capture loop: SessionStart injects a global ★ Insight instruction;
  a Stop hook harvests insights to ~/.dev-loop/queue; the on-demand
  knowledge-flush skill researches + verifies + dedups + routes each into the
  right semantic layer and opens ONE PR (no auto-merge — owner reviews).
- pre-flush-pr-gate.sh (PreToolUse) enforces the research/dedup/routing pipeline
  by blocking a knowledge-flush `gh pr create` unless an INGEST_REPORT with all
  three required sections is present. Scoped to flush PRs only; node-independent.
- Global install via marketplace; no repo allowlist.

Author: choiyounggi

.claude-plugin/marketplace.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "dev-loop",
+  "description": "Marketplace for dev-loop — a wiki-grounded implementation loop plugin for Claude Code (loop-orchestrator + dev-llm-wiki, merged).",
+  "owner": {
+    "name": "choiyounggi",
+    "url": "https://github.com/choiyounggi"
+  },
+  "plugins": [
+    {
+      "name": "dev-loop",
+      "description": "loop-orchestrator's verification loop with the plan step fixed to a wiki-grounded planning methodology (wiki-plan) over a bundled semantic-layer wiki, plus a knowledge-capture loop that harvests verified insights and opens reviewed wiki PRs via knowledge-flush.",
+      "category": "development",
+      "author": {
+        "name": "choiyounggi",
+        "url": "https://github.com/choiyounggi"
+      },
+      "source": {
+        "source": "url",
+        "url": "https://github.com/choiyounggi/dev-loop.git"
+      },
+      "homepage": "https://github.com/choiyounggi/dev-loop",
+      "version": "0.1.0",
+      "tags": [
+        "orchestrator",
+        "verification-loop",
+        "tdd",
+        "wiki",
+        "planning",
+        "knowledge-base",
+        "claude-code"
+      ]
+    }
+  ]
+}

.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "dev-loop",
+  "description": "loop-orchestrator's verification loop (TDD / PDCA / Reflexion) with the plan step FIXED to a wiki-grounded planning methodology (wiki-plan): every design decision is routed to a bundled semantic-layer wiki before code is written. Adds a knowledge-capture loop — sessions emit verified insights, and knowledge-flush researches, dedups, routes, and opens a wiki PR for owner review.",
+  "version": "0.1.0",
+  "author": {
+    "name": "choiyounggi",
+    "url": "https://github.com/choiyounggi"
+  },
+  "homepage": "https://github.com/choiyounggi/dev-loop",
+  "strict": false
+}

.github/workflows/release.yml

@@ -0,0 +1,42 @@
+# Create a GitHub Release (with auto-generated notes) when a version tag is
+# pushed. This plugin is installed via the Claude Code marketplace (a git repo),
+# not npm, so there is NO npm publish step — the Release is the versioning
+# artifact for marketplace users.
+#
+# Usage: bump .claude-plugin/plugin.json "version", commit, then:
+#   git tag vX.Y.Z && git push origin vX.Y.Z
+
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write   # needed to create the Release
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # Refuse if the tag and plugin.json version disagree (fail-fast).
+      - name: Verify tag matches plugin.json version
+        run: |
+          PKG_VERSION=$(jq -r .version .claude-plugin/plugin.json)
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+          echo "plugin.json: $PKG_VERSION"
+          echo "release tag: $TAG_VERSION"
+          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
+            echo "::error::Tag '$TAG_VERSION' does not match plugin.json '$PKG_VERSION'. Bump plugin.json or retag."
+            exit 1
+          fi
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true

.github/workflows/test.yml

@@ -0,0 +1,41 @@
+# Run the bats suite on every push to main and every PR, across macOS and Linux
+# (the plugin's shell scripts must be portable — design §12). Guards against
+# regressions before a release tag is cut.
+
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: test-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install bats + jq + tmux
+        run: |
+          if [ "$RUNNER_OS" = "macOS" ]; then
+            brew install bats-core jq tmux
+          else
+            sudo apt-get update
+            sudo apt-get install -y bats jq tmux
+          fi
+
+      - name: Run bats suite
+        run: bats tests/

.gitignore

@@ -0,0 +1,5 @@
+.orchestration/
+node_modules/
+.DS_Store
+*.log
+.claude/

AGENTS.md

@@ -0,0 +1,165 @@
+# dev-llm-wiki — Agent Schema
+
+You are the maintainer and consumer of this wiki. This file is the schema: it defines
+how the wiki is structured, how you route into it, how you write pages, and how you
+keep it healthy. Follow it exactly. When this file and your habits disagree, this file wins.
+
+## What this wiki is
+
+A case-routed knowledge base of development best practices and edge cases, written
+**for LLM agents to load as working context**. It is not documentation for humans to
+browse (humans are welcome, but every formatting rule below exists to make an agent's
+context precise and small).
+
+Three layers (Karpathy LLM-wiki pattern):
+
+| Layer | Path | Mutability |
+|-------|------|------------|
+| Schema | `AGENTS.md` (this file), `templates/` | Change only with repo owner approval |
+| Wiki | `wiki/**` , `INDEX.md`, `log.md` | You create and update via the workflows below |
+| Workflows | `skills/` | Change only with repo owner approval |
+
+## Directory layout
+
+```
+INDEX.md                     # root map: domain → when to route there
+log.md                       # append-only chronological change log
+wiki/<domain>/index.md       # domain map: category/page → when to load it
+wiki/<domain>/<category>/<page>.md
+templates/page.md            # canonical page template
+skills/ingest|query|lint/    # the three operations
+```
+
+## Routing protocol (how to consume)
+
+When working on a task and you need guidance from this wiki:
+
+1. Read `INDEX.md`. Match your task to a domain by its "route here when" line.
+   - **Several domains match**: route to the domain that owns the artifact you will
+     change (SQL/schema → databases; application code → backend; a failing system →
+     debugging). Reading a second domain's index to check is cheap and sanctioned;
+     bulk-loading pages from both is not.
+   - **Best match is marked `scaffold`**: it has no pages. Use the cross-pointers in
+     its index if any, take the next matching seeded domain, and append a `gap`
+     entry to `log.md`.
+2. Read that domain's `wiki/<domain>/index.md`. Select pages by their **"load when"
+   lines — these are the routing gate**. Load only pages whose line matches your
+   situation.
+3. After loading, the page's "When this applies" should confirm the match. If it
+   contradicts your situation, drop the page and append a `drift` entry to `log.md`
+   (index line and page trigger disagree — a lint defect), unless the page content
+   demonstrably serves your case anyway, in which case keep it and still log the drift.
+4. **Sanctioned extra hops**: when a loaded page routes you onward via an inline
+   `[page-id]` reference or a `related:` id, follow it — the citing directive is the
+   trigger. This is how constraint/index pages compose.
+5. If no page matches anywhere, answer from general knowledge **explicitly labeled
+   not wiki-backed**, and append a `gap` entry to `log.md`.
+6. Apply the page's directives:
+   - If your situation hits a listed edge case, follow the edge-case row, not the
+     general rule.
+   - Within a Do/decision table, when several rows match, apply the **most specific
+     row** (rows are ordered general → specific); when a general row and a
+     precondition-bearing row both fit, take the one that preserves the stated
+     invariant.
+
+Hard rule: never load a whole domain "for background". The index lines exist so you
+can decide relevance without opening pages.
+
+## Page format (how to write)
+
+Every page uses `templates/page.md`. Non-negotiable rules:
+
+1. **One case per page.** A page answers one situation. If you are writing "and also…",
+   split the page and cross-link under `related`.
+2. **≤ 120 lines of body.** Precision beats coverage. Link, don't inline.
+3. **Positive guidance only.** Every directive is "In situation X, do Y".
+   Anti-patterns may only appear in the `Instead of` table, where each row MUST pair
+   the anti-pattern with its replacement action. A "don't" without an "instead" is a
+   lint failure — a prohibition with no replacement invites the reader to improvise,
+   which is how hallucinations happen.
+4. **No vague qualifiers.** Words like "usually", "consider", "might want to",
+   "generally", "as appropriate" are banned in directive sentences. State the
+   condition that decides it: "When X, do A. When Y, do B." If you cannot state the
+   condition, the knowledge is not ready for a page — file it in the ingest queue.
+5. **Sources are mandatory.** Frontmatter `sources:` lists the evidence
+   (official docs, measured benchmarks, published post-mortems). Claims you cannot
+   source get `confidence: unverified` and are surfaced by lint until sourced or removed.
+6. **Case branches are tables.** When behavior differs by situation, use a
+   `| Case | Do |` table, not prose. Tables are what agents parse most reliably.
+
+### Frontmatter
+
+```yaml
+---
+id: <domain>-<category>-<slug>        # globally unique
+domain: databases
+category: indexing
+applies_to: [postgresql, mysql]       # or [general]
+confidence: verified | field-tested | unverified
+sources:
+  - <url or citation>
+last_verified: YYYY-MM-DD
+related: [<page id>, ...]
+---
+```
+
+`confidence` meanings — `verified`: backed by cited official docs or reproducible
+measurement. `field-tested`: worked in real production use; context described in the
+page. `unverified`: candidate knowledge; lint reports it until upgraded or removed.
+
+### Section skeleton
+
+```markdown
+# <Title — the situation, stated as a noun phrase>
+## When this applies      # trigger conditions, 1-4 lines, matchable without reading further
+## Do this                # directives; decision table if branching
+## Edge cases             # | Case | Then | table
+## Instead of             # | If you are about to | Do this instead | Why | (optional section)
+## Sources
+```
+
+## Operations
+
+Run these via the skill files, which contain the full step-by-step workflows:
+
+- **Ingest** (`skills/wiki-ingest/SKILL.md`) — add new knowledge: route it to domain/category,
+  merge into existing pages before creating new ones, cite sources, update indexes and `log.md`.
+- **Query** (`skills/wiki-query/SKILL.md`) — answer a question from the wiki with citations;
+  if the answer required synthesis across pages and is re-askable, file it as a new page.
+- **Lint** (`skills/wiki-lint/SKILL.md`) — health check: unsourced claims, "don't"s without
+  "instead"s, banned vague qualifiers, orphan pages, broken links, stale `last_verified`.
+
+Two further skills use the wiki to run development work (rather than maintain the wiki):
+
+- **Plan** (`skills/wiki-plan/SKILL.md`) — for a capable model: make every design decision
+  (wiki-grounded), then decompose the work into ordered task files sized for a small
+  model (≤3 files, ≤4 wiki pages, verifiable, self-contained), each mapping the exact
+  wiki pages that govern it.
+- **Implement** (`skills/wiki-implement/SKILL.md`) — for the small model executing one task:
+  read only the task file + its named wiki pages + named inputs, no improvisation
+  (missing decisions are reported BLOCKED, never guessed), verify, report in a fixed format.
+
+## Naming
+
+- Domains and categories: lowercase kebab-case nouns (`query-optimization`).
+- A domain may nest one subtree level when it splits by stack/environment
+  (`backend/common/`, `backend/java/`, `backend/node/`, `backend/python/`); page ids
+  then include the subtree: `backend-java-jpa-<slug>`. The domain `index.md` routes
+  concern-first (shared subtree) then stack; each stack subtree has its own `index.md`.
+- Page files: the situation, not the technology (`composite-index-column-order.md`,
+  not `postgres-tips.md`).
+- Page ids: `<domain>-<category>-<slug>` matching the file path.
+
+## Maintenance invariants
+
+After any wiki change, all of these must hold (lint checks them):
+
+1. Every page is listed in its domain `index.md` with an accurate "load when" line.
+   The line must enumerate the page's **distinct use cases** (including
+   constraint/uniqueness/design-time uses), not only its headline framing, and must
+   not contradict the page's "When this applies". Decision tables inside pages are
+   ordered general → specific.
+2. Every domain appears in `INDEX.md`.
+3. `log.md` has an appended entry: `## [YYYY-MM-DD] <ingest|revise|lint> | <summary>`.
+4. Every `related:` id and inline link resolves to an existing page.
+5. No page exceeds 120 body lines.

INDEX.md

@@ -0,0 +1,23 @@
+# Root Index — Domain Map
+
+Route by matching your current task to a "route here when" line, then open that
+domain's `index.md`. Load nothing else at this level.
+
+`scaffold` domains have **no pages yet** — do not route into them expecting answers;
+follow the cross-pointers in their index or take the next matching seeded domain
+(routing protocol step 1, `AGENTS.md`).
+
+| Domain | Status | Route here when |
+|--------|--------|-----------------|
+| [databases](wiki/databases/index.md) | **seeded** | Designing schemas/tables/keys, choosing or evaluating indexes, writing or optimizing queries, choosing transaction/isolation behavior |
+| [backend](wiki/backend/index.md) | **seeded** | Server-side application code — language-agnostic (`common/`: API contracts, idempotency, JWT, timeouts/retries, caching, jobs, transactions in app code, shared state/pools, errors) plus stack subtrees: `java/` (JPA, Spring proxies, JVM threads/memory), `node/` (event loop, promises, runtime validation, shutdown), `python/` (GIL/asyncio, pydantic, WSGI/ASGI workers, language traps) |
+| [frontend](wiki/frontend/index.md) | **seeded** | Web UI code: state placement, rendering performance, in-UI data fetching (races, infinite scroll), auth token handling, forms, XSS-safe output, accessibility |
+| [infrastructure](wiki/infrastructure/index.md) | **seeded** | CI/CD pipelines, secrets in build/deploy, container image builds, rollout/rollback strategy, observability (logs/metrics/alerting) |
+| [testing](wiki/testing/index.md) | **seeded** | Writing or structuring automated tests: level choice, cases/assertions, test data, mock decisions, flaky tests (release-process quality → qa) |
+| [qa](wiki/qa/index.md) | **seeded** | Release-quality process: release gates, regression scoping, bug reports, severity/priority triage, exploratory testing (writing automated test code → testing) |
+| [debugging](wiki/debugging/index.md) | **seeded** | Diagnosing a failure — finding what is wrong and why: reproducing, bisection, hypothesis testing, traces/logs, intermittent failures (fixing the diagnosed fault → its owning domain) |
+| [security](wiki/security/index.md) | **seeded** | Trust-boundary decisions: input validation, session-vs-token auth choice, per-resource authorization (IDOR), secrets hygiene, dependency trust, PII handling (XSS rendering → frontend; CI secrets → infrastructure; JWT implementation → backend/frontend auth) |
+| [platforms](wiki/platforms/index.md) | **seeded** | OS-level differences breaking code across macOS/Linux/Windows: shell portability, BSD-vs-GNU CLI, filesystem case/line endings, background services/cron, toolchain version pinning |
+| [mobile](wiki/mobile/index.md) | **seeded** | App-side iOS/Android/cross-platform: process death/state survival, offline-first sync, mobile-network calls, store rollout/hotfix strategy, startup time |
+
+All ten domains are seeded. New categories grow via `skills/wiki-ingest/SKILL.md`.

LICENSE

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