@boyingliu01/xp-gate 0.8.8 → 0.8.9

package/lib/arch.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Looks for architecture.yaml in CWD, then walks up to git root.
+function findArchConfig(startDir) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const candidate = path.join(dir, 'architecture.yaml');
+    if (fs.existsSync(candidate)) return candidate;
+    if (fs.existsSync(path.join(dir, '.git'))) return null;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function arch(args) {
+  const configIdx = args.indexOf('--config');
+  const explicitConfig = configIdx >= 0 ? args[configIdx + 1] : null;
+  const config = explicitConfig || findArchConfig(process.cwd());
+
+  if (!config) {
+    console.error('[xp-gate arch] ERROR: architecture.yaml not found in CWD or git root');
+    console.error('  Create one or pass --config <path>');
+    return Promise.resolve(1);
+  }
+
+  if (!fs.existsSync(config)) {
+    console.error(`[xp-gate arch] ERROR: config file not found: ${config}`);
+    return Promise.resolve(1);
+  }
+
+  const result = spawnSync('npx', ['-y', '@archlinter/cli', 'scan', '.', '--config', config], {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  if (result.error && result.error.code === 'ENOENT') {
+    console.error('[xp-gate arch] ERROR: npx not found in PATH. Install Node.js >=18.');
+    return Promise.resolve(1);
+  }
+
+  return Promise.resolve(result.status === null ? 1 : result.status);
+}
+
+module.exports = { arch };

package/lib/check.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { principles } = require('./principles.js');
+const { arch } = require('./arch.js');
+
+// Runs the user-invokable subset of quality gates on a path. Mirrors what the
+// pre-commit hook does, but as a standalone CLI surface. Intentionally narrower
+// than the full pre-commit run (no git staging context, no Boy Scout baseline).
+// Currently delegates to: Gate 4 (Principles) + Gate 6 (Architecture).
+async function check(args) {
+  const target = args[0];
+  if (!target) {
+    console.error('Usage: xp-gate check <file_or_directory> [--gates principles,arch]');
+    return 1;
+  }
+
+  const gatesIdx = args.indexOf('--gates');
+  const gateList = gatesIdx >= 0
+    ? args[gatesIdx + 1].split(',').map(s => s.trim()).filter(Boolean)
+    : ['principles', 'arch'];
+
+  let failures = 0;
+  let ran = 0;
+
+  if (gateList.includes('principles')) {
+    console.log('━━━ Gate 4: Principles ━━━');
+    const code = await principles([target]);
+    if (code !== 0) failures += 1;
+    ran += 1;
+  }
+
+  if (gateList.includes('arch')) {
+    console.log('━━━ Gate 6: Architecture ━━━');
+    const code = await arch([]);
+    if (code !== 0) failures += 1;
+    ran += 1;
+  }
+
+  if (ran === 0) {
+    console.error(`[xp-gate check] No valid gates in --gates list: ${gateList.join(',')}`);
+    console.error('  Available gates: principles, arch');
+    return 1;
+  }
+
+  console.log('');
+  console.log(`[xp-gate check] ${ran - failures}/${ran} gate(s) passed`);
+  return failures === 0 ? 0 : 1;
+}
+
+module.exports = { check };

package/lib/principles.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Resolves repo root for the installed xp-gate npm package, or the development
+// checkout when running from source. Walks up looking for either:
+//   - src/principles/index.ts (this repo / dev mode)
+//   - ../../src/principles/index.ts (installed under node_modules/@boyingliu01/xp-gate)
+function findPrinciplesEntry() {
+  const candidates = [
+    path.resolve(__dirname, '..', '..', '..', 'src', 'principles', 'index.ts'),
+    path.resolve(__dirname, '..', '..', 'src', 'principles', 'index.ts'),
+    path.resolve(process.cwd(), 'src', 'principles', 'index.ts'),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function principles(args) {
+  const target = args[0];
+  if (!target) {
+    console.error('Usage: xp-gate principles <file_or_directory> [--format console|json|sarif]');
+    return Promise.resolve(1);
+  }
+
+  const formatIdx = args.indexOf('--format');
+  const format = formatIdx >= 0 ? args[formatIdx + 1] : 'console';
+
+  const entry = findPrinciplesEntry();
+  if (!entry) {
+    console.error('[xp-gate principles] ERROR: cannot locate src/principles/index.ts');
+    console.error('  Run from inside the xp-gate repo, or install via npm install -g @boyingliu01/xp-gate');
+    return Promise.resolve(1);
+  }
+
+  const result = spawnSync('npx', ['-y', 'tsx', entry, '--files', target, '--format', format], {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  return Promise.resolve(result.status === null ? 1 : result.status);
+}
+
+module.exports = { principles };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"

package/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "xp-gate",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "displayName": "XP-Gate",
-  "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 6 quality gates, Sprint Flow, and Delphi multi-expert review.",
+  "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 10 quality gates (Gate 0-9), Sprint Flow (11 phases), and Delphi multi-expert review (>=91% consensus).",
   "author": {
     "name": "boyingliu01"
   },

package/plugins/claude-code/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Commit:** 4517f2b
+**Generated:** 2026-06-11
+**Commit:** c18f82b
 **Branch:** main
-**Version:** v0.8.1
+**Version:** 0.8.9.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥91% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.

package/plugins/claude-code/skills/sprint-flow/AGENTS.md

@@ -1,68 +1,115 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Version:** v0.8.1
+**Generated:** 2026-06-11
+**Commit:** c18f82b
+**Branch:** main
+**Version:** 0.8.9.0
 
 ## OVERVIEW
-7-phase development pipeline: THINK→PLAN→BUILD→REVIEW→USER ACCEPT→FEEDBACK→SHIP, with ralph-loop default build mode.
+**11-phase** development pipeline: ISOLATE → AUTO-ESTIMATE → THINK → PLAN → BUILD → REVIEW → USER ACCEPTANCE → FEEDBACK → SHIP → LAND → CLEANUP. Phase 2 default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE in Phase 1: design must pass Delphi review (≥91% consensus) before any coding.
+
+> **Doc drift**: README/CAPABILITIES still describe a "7-phase" pipeline. The canonical 11-phase model lives in `SKILL.md` and is what actually executes. See root `AGENTS.md` → "Known Drift" #4.
 
 ## STRUCTURE
 ```
 skills/sprint-flow/
-├── SKILL.md              # 7-phase pipeline definition
+├── SKILL.md              # 11-phase pipeline definition (canonical)
+├── AGENTS.md             # This file (mirrored to 7 other locations — DO NOT edit mirrors)
 ├── evals/                # Evaluation test cases
-├── evolution-history.json # Skill evolution tracking
-├── evolution-log.md      # Change history
-├── references/           # Phase reference docs
-│   ├── phase-0-think.md  # THINK phase guidelines
-│   └── ...               # Other phase docs
-└── templates/            # Sprint templates
+├── evolution-history.json
+├── evolution-log.md
+├── references/
+│   ├── phase-minus-0-5-auto-estimate.md  # Phase -0.5: AUTO-ESTIMATE
+│   ├── phase-0-think.md                   # Phase 0: brainstorming → CONTEXT.md + ADR
+│   ├── phase-1-plan.md                    # Phase 1: autoplan + delphi-review (HARD-GATE)
+│   ├── phase-2-build.md                   # Phase 2: ralph-loop default + TDD + test-align
+│   ├── phase-3-review.md                  # Phase 3: code-walkthrough + QA + benchmark
+│   ├── phase-4-uat.md                     # Phase 4: USER ACCEPTANCE
+│   ├── phase-5-feedback.md                # Phase 5: retro + debugging + learn
+│   ├── phase-6-ship.md                    # Phase 6: finishing-dev-branch + PR
+│   ├── phase-7-land.md                    # Phase 7: land + deploy
+│   ├── phase-8-cleanup.md                 # Phase 8: sprint branch cleanup
+│   ├── force-levels.md                    # Phase forcing rules
+│   └── components/                        # Reusable phase building blocks
+└── templates/
+    ├── auto-estimate-output-template.md
+    ├── auto-estimate-learning-log.md
+    ├── pain-document-template.md
+    ├── sprint-progress-template.md
+    ├── sprint-summary-template.md
+    └── emergent-issues-template.md
 ```
 
 ## WHERE TO LOOK
 | Task | Location | Notes |
 |------|----------|-------|
-| Pipeline def | SKILL.md | 7 phases with hard gates |
+| Pipeline definition | SKILL.md | 11 phases with HARD-GATE between Phase 1 and Phase 2 |
+| Auto-estimate phase | references/phase-minus-0-5-auto-estimate.md | Sizing pass before THINK |
 | THINK phase | references/phase-0-think.md | brainstorming → CONTEXT.md + ADR |
-| Build mode | SKILL.md | ralph-loop (default) vs parallel |
+| PLAN phase + HARD-GATE | references/phase-1-plan.md | autoplan → delphi-review → specification.yaml |
+| BUILD phase | references/phase-2-build.md | ralph-loop (default) vs parallel |
+| Force-level rules | references/force-levels.md | Defines when each phase becomes mandatory |
+| Templates | templates/ | Auto-estimate, sprint progress/summary, pain doc, emergent issues |
+
+## THE 11 PHASES
 
-## 7 PHASES
 | Phase | Name | Key Action | Hard Gate |
 |-------|------|-----------|-----------|
-| 0 | THINK | brainstorming, CONTEXT.md, ADR | — |
-| 1 | PLAN | autoplan → delphi-review → specification.yaml | HARD-GATE: design must pass |
-| 2 | BUILD | ralph-loop (REQ-level iteration) + TDD + test-align | — |
+| -1 | ISOLATE | Isolate working tree / worktree creation | — |
+| -0.5 | AUTO-ESTIMATE | Sizing pass; emits estimate template | — |
+| 0 | THINK | brainstorming → CONTEXT.md + ADR | — |
+| 1 | PLAN | autoplan → delphi-review → specification.yaml | **HARD-GATE**: design must reach ≥91% Delphi consensus |
+| 2 | BUILD | ralph-loop (REQ-level, default) + TDD + test-spec-alignment | — |
 | 3 | REVIEW | code-walkthrough + QA + benchmark | — |
-| 4 | USER ACCEPT | Manual verification | — |
-| 5 | FEEDBACK | Retro + debugging + learn | — |
-| 6 | SHIP | finishing-dev-branch + PR/merge | — |
+| 4 | USER ACCEPTANCE | Manual verification | — |
+| 5 | FEEDBACK | retro + debugging + `learn` (Sprint-level) | — |
+| 6 | SHIP | finishing-a-development-branch → PR | — |
+| 7 | LAND | land + deploy + canary | — |
+| 8 | CLEANUP | Sprint branch cleanup (per `docs/plans/2026-06-06-sprint-branch-cleanup-design.md`) | — |
 
 ## CONVENTIONS
-- ralph-loop is Phase 2 **default** mode (saves 40-67% tokens vs parallel)
-- delphi-review HARD-GATE in Phase 1: design unapproved → BLOCK coding
-- Each REQ in ralph-loop gets clean context (no linear accumulation)
-- `learn` called at Phase 5 + each REQ completion
+- **ralph-loop is Phase 2 default**. Each REQ runs in a clean context (no linear accumulation), saving 40-67% tokens vs parallel mode.
+- **delphi-review HARD-GATE in Phase 1**: design must reach ≥91% consensus across ≥2 model providers, domestic models only. Unapproved → BLOCK coding.
+- **`learn` is called twice**: once per REQ in Phase 2 (ralph-loop internal, `progress.log` permanent/contextual classification) and once in Phase 5 (Sprint-level retro).
+- **Phase isolation**: each phase has explicit entry/exit criteria documented in its `references/phase-*.md` file.
+- **Emergent Requirements** discovered in Phase 4 (USER ACCEPTANCE) are explicitly captured via `templates/emergent-issues-template.md` — never silently merged.
+- **Auto-detection**: Phase 0 uses `src/npm-package/lib/ui-detector.ts` to pick the right tech-stack templates.
 
 ## ANTI-PATTERNS (THIS PROJECT)
-- Do NOT skip delphi-review in Phase 1 — HARD-GATE blocks implementation
-- Do NOT use parallel build mode unless explicitly requested
-- Do NOT enter Phase 1 (PLAN) without completing THINK phase
-- DO NOT implement before design approval
+- Do NOT skip `delphi-review` in Phase 1 — HARD-GATE blocks implementation.
+- Do NOT use parallel build mode unless explicitly requested. Ralph-loop is the default for a reason.
+- Do NOT enter Phase 1 (PLAN) without completing Phase 0 (THINK).
+- Do NOT implement before design is APPROVED — Phase 1 must reach Delphi consensus first.
+- Do NOT merge an Emergent Requirement into the original Sprint silently — capture it via the template.
+- Do NOT terminate Delphi review before ≥91% consensus or 5 rounds, whichever first.
 
 ## UNIQUE STYLES
-- Auto-detects UI framework (ui-detector.ts in npm-package/lib/)
-- Supports --type and --lang flags for tech stack selection
-- Phase isolation: each phase has specific entry/exit criteria
-- Emergent Requirements acknowledged: user acceptance phase built in
+- **11 phases** including negative-numbered pre-phases (-1, -0.5) — intentional, captures the work that happens before "real" coding starts.
+- **HARD-GATE** between PLAN and BUILD is enforced both in the SKILL.md instructions and in the Claude Code plugin's PreToolUse hook (`plugins/claude-code/bin/delphi-review-guard.sh`).
+- **Per-REQ clean context in ralph-loop** = the core efficiency mechanism. Sprint-flow specifically chooses this over parallel mode.
+- **Tech-stack auto-detection** via `--type` and `--lang` flags or `ui-detector.ts`.
 
 ## COMMANDS
 ```bash
+/sprint-flow "开发用户登录"                                     # Full 11-phase pipeline
+/sprint-flow "开发用户登录" --type web-nextjs --lang typescript # Pin tech stack
+/sprint-flow "开发用户登录" --phase build-only                  # Skip planning (advanced)
+/sprint-flow "开发用户登录" --mode parallel                     # Legacy all-at-once (NOT default)
 /delphi-review "开发用户登录" --type web-nextjs --lang typescript
-/sprint-flow "开发用户登录" --phase build-only
-/sprint-flow "开发用户登录" --mode parallel  # Legacy all-at-once
 ```
 
 ## NOTES
-- Integrates brainstorming, autoplan, delphi-review, TDD, test-specification-alignment
-- ralph-loop internal learnings via progress.log (permanent/contextual classification)
-- Phase 5 calls gstack/learn for Sprint-level retrospective
+- Integrates: brainstorming, autoplan, delphi-review, TDD, test-specification-alignment, qa, design-review, benchmark, systematic-debugging, retro, learn, finishing-a-development-branch.
+- ralph-loop's internal learnings are persisted via `progress.log` (permanent vs contextual classification).
+- Phase 5 calls `gstack/learn` for Sprint-level retrospective.
+- Phase 8 cleanup behavior is governed by `docs/plans/2026-06-06-sprint-branch-cleanup-design.md`.
+- This `AGENTS.md` is the canonical version. **7 byte-identical mirrors** exist at:
+  - `plugins/claude-code/skills/sprint-flow/AGENTS.md`
+  - `plugins/opencode/skills/sprint-flow/AGENTS.md`
+  - `plugins/qoder/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/plugins/claude-code/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/plugins/opencode/skills/sprint-flow/AGENTS.md`
+  - `src/npm-package/plugins/qoder/skills/sprint-flow/AGENTS.md`
+  Mirrors are updated by `scripts/copy-skills.sh`. Do NOT edit them by hand.
+

package/plugins/claude-code/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Commit:** 4517f2b
+**Generated:** 2026-06-11
+**Commit:** c18f82b
 **Branch:** main
-**Version:** v0.8.1
+**Version:** 0.8.9.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/plugins/opencode/README.md

@@ -4,9 +4,21 @@ OpenCode plugin exposing xp-gate quality gates and AI workflow skills.
 
 ## Tools
 
-- **gate-check**: Run all 6 quality gates on a file/directory
-- **gate-principles**: Run Clean Code + SOLID principles checker
-- **gate-arch**: Run architecture validation
+These three tools are **dual-surface**: callable both as OpenCode tools (from
+inside an OpenCode session) and as `xp-gate` CLI subcommands (from any shell).
+Both paths produce identical output. See repo README for the matching CLI table.
+
+- **gate-check** ⇄ `xp-gate check <path>`: Run user-invokable quality gates
+  (Gate 4 Principles + Gate 6 Architecture) on a file or directory.
+- **gate-principles** ⇄ `xp-gate principles <path>`: Run Clean Code + SOLID
+  principles checker (Gate 4 standalone).
+- **gate-arch** ⇄ `xp-gate arch`: Run architecture validation (Gate 6
+  standalone, layer boundary checks).
+
+> Earlier docs said "all 6 quality gates" — that was inaccurate. `gate-check`
+> intentionally runs only the two user-invokable gates (Principles + Arch); the
+> full 10-gate pre-commit suite (Gate 0-9) is enforced by `xp-gate init`'s git
+> hooks, not by this tool. Fixes #208.
 
 ## Installation
 
@@ -29,10 +41,14 @@ Or via local path (development):
 ## Requirements
 
 - OpenCode v0.11+
-- xp-gate npm package installed globally (for `gate-check` tool)
-- Repository with `src/principles/index.ts` (for `gate-principles` tool)
-- `architecture.yaml` in repo root (for `gate-arch` tool)
+- One of:
+  - `xp-gate` CLI installed globally (`npm install -g @boyingliu01/xp-gate`) — **preferred**, or
+  - the xp-gate repo checked out locally with `src/principles/index.ts` reachable — **fallback** (the tool will shell out via `npx -y tsx`)
+- `architecture.yaml` in repo root (for `gate-arch` only)
 
 ## Graceful Degradation
 
-If xp-gate CLI is unavailable, tools return helpful install instructions instead of failing.
+Every tool runs a chained shell-out: it first tries `xp-gate <subcommand>` and,
+only if that's not on `PATH`, falls back to invoking the underlying checker
+source directly. If both paths fail, the tool returns install instructions
+instead of throwing.

package/plugins/opencode/index.ts

@@ -1,57 +1,69 @@
 /**
  * XP-Gate OpenCode Plugin
  *
- * Exposes 3 custom tools for OpenCode users:
- *  - gate-check:      Run all xp-gate quality checks on a file or directory
- *  - gate-principles: Run Clean Code + SOLID principles checker
- *  - gate-arch:       Run architecture validation
+ * Exposes 3 OpenCode tools that mirror the equivalent `xp-gate` CLI subcommands:
+ *  - gate-check:      Run user-invokable quality gates (Gate 4 Principles + Gate 6 Arch) on a path
+ *  - gate-principles: Run Clean Code + SOLID principles checker (Gate 4 standalone)
+ *  - gate-arch:       Run architecture validation (Gate 6 standalone)
  *
- * Graceful degradation: if xp-gate CLI not installed, tools return install instructions.
+ * Dual-surface design (fixes #208): every tool is callable BOTH from inside an
+ * OpenCode session (as these tools) AND from a plain shell (as `xp-gate check`,
+ * `xp-gate principles`, `xp-gate arch`). The tools prefer the global `xp-gate`
+ * CLI when available, but fall back to running the checker source directly via
+ * `npx -y tsx` so they work even before `npm install -g @boyingliu01/xp-gate`.
  */
 import { tool } from "@opencode-ai/plugin"
 import { z } from "zod"
 
-export const XpGatePlugin = async (input) => {
+interface OpenCodePluginInput {
+  directory: string
+  $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<{ text(): Promise<string> }>
+}
+
+export const XpGatePlugin = async (input: OpenCodePluginInput) => {
   const { directory, $ } = input
 
   return {
     tool: {
       "gate-check": tool({
         description:
-          "Run xp-gate quality checks on a file or directory. Requires xp-gate CLI installed globally.",
+          "Run xp-gate user-invokable quality gates (Gate 4 Principles + Gate 6 Architecture) on a file or directory. Prefers global xp-gate CLI; falls back to running checker source directly.",
         args: {
           path: z.string().describe("File or directory path (absolute or relative to workspace)"),
-          gates: z.array(z.string()).optional().describe("Optional gate subset (e.g. ['principles', 'tests'])"),
+          gates: z.array(z.string()).optional().describe("Optional gate subset (e.g. ['principles', 'arch'])"),
         },
         async execute(args, ctx) {
           const cwd = ctx.directory || directory
           const target = args.path.startsWith("/") ? args.path : `${cwd}/${args.path}`
-          const gates = args.gates?.length ? ` --gates ${args.gates.join(",")}` : ""
+          const gatesFlag = args.gates?.length ? ` --gates ${args.gates.join(",")}` : ""
+          // Prefer the installed xp-gate CLI. Fall back to invoking the same
+          // subcommand source directly via npx tsx so the tool still works in
+          // a fresh clone before `npm install -g @boyingliu01/xp-gate`.
+          const cmd = `cd "${cwd}" && (command -v xp-gate >/dev/null 2>&1 && xp-gate check "${target}"${gatesFlag} || node ${directory}/src/npm-package/bin/xp-gate.js check "${target}"${gatesFlag})`
           try {
-            const result = await $`bash -c ${`cd "${cwd}" && command -v xp-gate >/dev/null 2>&1 && xp-gate check "${target}"${gates}`}`
+            const result = await $`bash -c ${cmd}`
             const text = await result.text()
-            return text || "[XP-Gate] Check complete."
+            return text || "[XP-Gate] Check complete (no violations)."
           } catch (err) {
-            return `[XP-Gate] xp-gate CLI not found.\nInstall: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
+            return `[XP-Gate] gate-check failed.\nInstall xp-gate CLI: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
           }
         },
       }),
       "gate-principles": tool({
         description:
-          "Run Clean Code + SOLID principles checker on a file.",
+          "Run Clean Code + SOLID principles checker (Gate 4 standalone) on a file or directory.",
         args: {
-          path: z.string().describe("Source file path to check"),
+          path: z.string().describe("Source file or directory path to check"),
         },
         async execute(args, ctx) {
           const cwd = ctx.directory || directory
           const target = args.path.startsWith("/") ? args.path : `${cwd}/${args.path}`
-
-          // Try xp-gate CLI first (preferred), fall back to npx tsx
-          const cmd = `cd "${cwd}" && command -v xp-gate >/dev/null 2>&1 && xp-gate principles "${target}" || npx -y tsx ${directory}/src/principles/index.ts --files "${target}" --format console`
+          // Try xp-gate CLI first, fall back to the principles source directly.
+          const cmd = `cd "${cwd}" && (command -v xp-gate >/dev/null 2>&1 && xp-gate principles "${target}" || npx -y tsx ${directory}/src/principles/index.ts --files "${target}" --format console)`
           try {
             const result = await $`bash -c ${cmd}`
             const text = await result.text()
-            return text || "[XP-Gate] Principles check complete."
+            return text || "[XP-Gate] Principles check complete (no violations)."
           } catch (err) {
             return `[XP-Gate] Principles checker failed.\nInstall xp-gate CLI: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
           }
@@ -59,18 +71,21 @@ export const XpGatePlugin = async (input) => {
       }),
       "gate-arch": tool({
         description:
-          "Run architecture validation (layer boundary checks) on the repository.",
+          "Run architecture validation (Gate 6 standalone, layer boundary checks) on the repository.",
         args: {
           config: z.string().describe("Path to architecture config file").default("architecture.yaml"),
         },
         async execute(args, ctx) {
           const cwd = ctx.directory || directory
+          // Prefer xp-gate CLI; fall back to @archlinter/cli directly so the tool
+          // also works without xp-gate installed (matches gate-principles pattern).
+          const cmd = `cd "${cwd}" && (command -v xp-gate >/dev/null 2>&1 && xp-gate arch --config ${args.config} || npx -y @archlinter/cli scan . --config ${args.config})`
           try {
-            const result = await $`bash -c ${`cd "${cwd}" && npx archlint check --config ${args.config}`}`
+            const result = await $`bash -c ${cmd}`
             const text = await result.text()
             return text || "[XP-Gate] Architecture check complete."
           } catch (err) {
-            return `[XP-Gate] Architecture validation requires archlint + ${args.config}.\n${err instanceof Error ? err.message : ""}`
+            return `[XP-Gate] Architecture validation failed.\nRequires architecture.yaml in repo root.\nInstall xp-gate CLI: npm install -g @boyingliu01/xp-gate\n${err instanceof Error ? err.message : ""}`
           }
         },
       }),

package/plugins/opencode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "type": "module",
   "main": "index.ts",
   "description": "XP-Gate quality gates + AI workflow skills for OpenCode",

package/plugins/opencode/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Commit:** 4517f2b
+**Generated:** 2026-06-11
+**Commit:** c18f82b
 **Branch:** main
-**Version:** v0.8.1
+**Version:** 0.8.9.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥91% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.