prizmkit 1.1.5 → 1.1.7

package/bundled/skills/prizmkit-verify/scripts/verify-light.py

@@ -0,0 +1,402 @@
+#!/usr/bin/env python3
+"""PrizmKit Light Verification Script — static checks for framework integrity.
+
+Usage:
+    python3 verify-light.py                    # Run all rounds
+    python3 verify-light.py --round R1         # Run specific round
+    python3 verify-light.py --round R1 R2 R4   # Run multiple rounds
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+# --- Configuration ---
+
+PROJECT_ROOT = Path(__file__).resolve().parents[5]  # core/skills/prizmkit-skill/prizmkit-verify/scripts/verify-light.py → root (5 levels up)
+
+SKILL_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "prizmkit-skill"
+PIPELINE_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "orchestration-skill" / "pipelines"
+WORKFLOW_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
+DEV_PIPELINE_DIR = PROJECT_ROOT / "dev-pipeline"
+ALL_SKILLS_DIR = PROJECT_ROOT / "core" / "skills"
+
+# Expected items per layer
+EXPECTED_PIPELINE_SKILLS = {
+    "app-planner", "feature-planner", "bug-planner", "refactor-planner",
+    "feature-pipeline-launcher", "bugfix-pipeline-launcher", "refactor-pipeline-launcher",
+}
+EXPECTED_WORKFLOW_SKILLS = {
+    "feature-workflow", "bug-fix-workflow", "refactor-workflow", "recovery-workflow",
+}
+
+# --- Helpers ---
+
+class Result:
+    def __init__(self):
+        self.passed = 0
+        self.warned = 0
+        self.failed = 0
+        self.details = []
+
+    def ok(self, msg):
+        self.passed += 1
+        self.details.append(("PASS", msg))
+
+    def warn(self, msg):
+        self.warned += 1
+        self.details.append(("WARN", msg))
+
+    def fail(self, msg):
+        self.failed += 1
+        self.details.append(("FAIL", msg))
+
+    @property
+    def status(self):
+        if self.failed > 0:
+            return "FAIL"
+        if self.warned > 0:
+            return "WARN"
+        return "PASS"
+
+    def summary(self):
+        return f"PASS={self.passed} WARN={self.warned} FAIL={self.failed}"
+
+
+def parse_frontmatter(skill_md_path):
+    """Extract YAML frontmatter from SKILL.md."""
+    text = skill_md_path.read_text(encoding="utf-8")
+    match = re.match(r"^---\n(.*?)\n---", text, re.DOTALL)
+    if not match:
+        return {}
+    fm = {}
+    for line in match.group(1).split("\n"):
+        if ":" in line:
+            key, val = line.split(":", 1)
+            fm[key.strip()] = val.strip().strip('"').strip("'")
+    return fm
+
+
+def find_skill_dirs(base_dir):
+    """Find all directories containing SKILL.md under base_dir."""
+    return sorted(
+        d for d in base_dir.iterdir()
+        if d.is_dir() and (d / "SKILL.md").exists()
+    )
+
+
+def collect_all_skill_names():
+    """Collect all known skill names across all categories."""
+    names = set()
+    for category_dir in ALL_SKILLS_DIR.iterdir():
+        if not category_dir.is_dir() or category_dir.name.startswith("."):
+            continue
+        # Direct skill dirs
+        for d in category_dir.iterdir():
+            if d.is_dir() and (d / "SKILL.md").exists():
+                names.add(d.name)
+            # Nested (pipelines/, workflows/)
+            if d.is_dir() and not (d / "SKILL.md").exists():
+                for sub in d.iterdir():
+                    if sub.is_dir() and (sub / "SKILL.md").exists():
+                        names.add(sub.name)
+    return names
+
+
+# --- Round Checks ---
+
+def run_r1(result: Result):
+    """R1: L1 Skill Layer Light checks."""
+    print("\n=== R1: L1 Skill Layer ===")
+    skill_dirs = find_skill_dirs(SKILL_LAYER_DIR)
+    all_skill_names = collect_all_skill_names()
+
+    if not skill_dirs:
+        result.fail("No skill directories found in prizmkit-skill/")
+        return
+
+    print(f"  Found {len(skill_dirs)} skills")
+
+    for skill_dir in skill_dirs:
+        skill_name = skill_dir.name
+        skill_md = skill_dir / "SKILL.md"
+
+        # 1. Frontmatter validation
+        fm = parse_frontmatter(skill_md)
+        if not fm.get("name"):
+            result.fail(f"[{skill_name}] Missing 'name' in frontmatter")
+        elif fm["name"] != skill_name:
+            result.fail(f"[{skill_name}] name '{fm['name']}' != dir '{skill_name}'")
+        else:
+            result.ok(f"[{skill_name}] Frontmatter name OK")
+
+        if not fm.get("description"):
+            result.fail(f"[{skill_name}] Missing 'description' in frontmatter")
+        else:
+            result.ok(f"[{skill_name}] Frontmatter description OK")
+
+        # 2. ${SKILL_DIR} reference resolution
+        content = skill_md.read_text(encoding="utf-8")
+        refs = re.findall(r'\$\{SKILL_DIR\}/([^\s`"\')]+)', content)
+        for ref in refs:
+            resolved = skill_dir / ref
+            if resolved.exists():
+                result.ok(f"[{skill_name}] Asset ref '{ref}' exists")
+            else:
+                result.fail(f"[{skill_name}] Asset ref '{ref}' NOT FOUND at {resolved}")
+
+        # 3. Cross-skill references
+        cross_refs = re.findall(r'(?<!\w)/prizmkit-[\w-]+(?=[\s`"\',\)])', content)
+        for ref in cross_refs:
+            ref_name = ref.lstrip("/")
+            if ref_name in all_skill_names:
+                result.ok(f"[{skill_name}] Cross-ref '{ref_name}' exists")
+            else:
+                result.warn(f"[{skill_name}] Cross-ref '{ref_name}' not found as skill dir")
+
+    # 4. ESLint
+    try:
+        lint_result = subprocess.run(
+            ["npm", "run", "lint"], capture_output=True, text=True,
+            cwd=str(PROJECT_ROOT), timeout=30,
+        )
+        errors = len(re.findall(r"(\d+) error[^s]", lint_result.stdout + lint_result.stderr))
+        if lint_result.returncode == 0 or errors == 0:
+            result.ok("ESLint: 0 errors")
+        else:
+            result.fail(f"ESLint: {errors} errors found")
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        result.warn(f"ESLint: could not run ({e})")
+
+    # 5. Ruff
+    try:
+        ruff_result = subprocess.run(
+            ["npm", "run", "lint:py"], capture_output=True, text=True,
+            cwd=str(PROJECT_ROOT), timeout=30,
+        )
+        if ruff_result.returncode == 0:
+            result.ok("Ruff: all checks passed")
+        else:
+            result.fail(f"Ruff: {ruff_result.stdout.strip()}")
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        result.warn(f"Ruff: could not run ({e})")
+
+
+def run_r2(result: Result):
+    """R2: L2 Pipeline Layer Light checks."""
+    print("\n=== R2: L2 Pipeline Layer ===")
+    skill_dirs = find_skill_dirs(PIPELINE_LAYER_DIR)
+    found_names = {d.name for d in skill_dirs}
+
+    # Check expected skills present
+    for expected in EXPECTED_PIPELINE_SKILLS:
+        if expected in found_names:
+            result.ok(f"[{expected}] Skill exists")
+        else:
+            result.fail(f"[{expected}] Expected skill NOT FOUND")
+
+    # Frontmatter validation
+    for skill_dir in skill_dirs:
+        fm = parse_frontmatter(skill_dir / "SKILL.md")
+        if fm.get("name") == skill_dir.name and fm.get("description"):
+            result.ok(f"[{skill_dir.name}] Frontmatter OK")
+        else:
+            result.fail(f"[{skill_dir.name}] Frontmatter invalid: {fm}")
+
+    # Schema version consistency
+    scenarios = [
+        ("feature", "feature-list-schema.json", "init-pipeline.py"),
+        ("bugfix", "bug-fix-list-schema.json", "init-bugfix-pipeline.py"),
+        ("refactor", "refactor-list-schema.json", "init-refactor-pipeline.py"),
+    ]
+    for scenario, schema_file, init_script in scenarios:
+        schema_path = DEV_PIPELINE_DIR / "templates" / schema_file
+        init_path = DEV_PIPELINE_DIR / "scripts" / init_script
+
+        if not schema_path.exists():
+            result.fail(f"[{scenario}] Schema file missing: {schema_file}")
+            continue
+        if not init_path.exists():
+            result.fail(f"[{scenario}] Init script missing: {init_script}")
+            continue
+
+        # Extract schema const value
+        try:
+            schema_data = json.loads(schema_path.read_text())
+            schema_const = (
+                schema_data.get("properties", {})
+                .get("$schema", {})
+                .get("const", "NOT_FOUND")
+            )
+        except json.JSONDecodeError:
+            result.fail(f"[{scenario}] Schema file is not valid JSON")
+            continue
+
+        # Extract expected schema from init script
+        init_content = init_path.read_text()
+        match = re.search(r'EXPECTED_SCHEMA\s*=\s*["\']([^"\']+)', init_content)
+        init_expected = match.group(1) if match else "NOT_FOUND"
+
+        if schema_const == init_expected:
+            result.ok(f"[{scenario}] Schema version match: {schema_const}")
+        else:
+            result.fail(f"[{scenario}] Schema version MISMATCH: template={schema_const}, init={init_expected}")
+
+    # Launcher script path references
+    for scenario, script in [("feature", "run-feature.sh"), ("bugfix", "run-bugfix.sh"), ("refactor", "run-refactor.sh")]:
+        script_path = DEV_PIPELINE_DIR / script
+        if script_path.exists() and os.access(script_path, os.X_OK):
+            result.ok(f"[{scenario}] Script {script} exists and executable")
+        elif script_path.exists():
+            result.warn(f"[{scenario}] Script {script} exists but NOT executable")
+        else:
+            result.fail(f"[{scenario}] Script {script} NOT FOUND")
+
+
+def run_r3(result: Result):
+    """R3: L3 Workflow Layer Light checks."""
+    print("\n=== R3: L3 Workflow Layer ===")
+    skill_dirs = find_skill_dirs(WORKFLOW_LAYER_DIR)
+    found_names = {d.name for d in skill_dirs}
+    pipeline_names = {d.name for d in find_skill_dirs(PIPELINE_LAYER_DIR)}
+
+    # Check expected skills
+    for expected in EXPECTED_WORKFLOW_SKILLS:
+        if expected in found_names:
+            result.ok(f"[{expected}] Workflow exists")
+        else:
+            result.fail(f"[{expected}] Expected workflow NOT FOUND")
+
+    for skill_dir in skill_dirs:
+        skill_name = skill_dir.name
+        skill_md = skill_dir / "SKILL.md"
+
+        # Frontmatter
+        fm = parse_frontmatter(skill_md)
+        if fm.get("name") == skill_name and fm.get("description"):
+            result.ok(f"[{skill_name}] Frontmatter OK")
+        else:
+            result.fail(f"[{skill_name}] Frontmatter invalid")
+
+        # Pipeline skill references
+        content = skill_md.read_text(encoding="utf-8")
+        for pipeline_ref in re.findall(r'`([\w-]+-planner|[\w-]+-pipeline-launcher)`', content):
+            if pipeline_ref in pipeline_names:
+                result.ok(f"[{skill_name}] Pipeline ref '{pipeline_ref}' exists")
+            else:
+                result.warn(f"[{skill_name}] Pipeline ref '{pipeline_ref}' not found")
+
+        # Checkpoint naming
+        checkpoints = re.findall(r'CP-\w+-\d+', content)
+        if checkpoints:
+            result.ok(f"[{skill_name}] {len(checkpoints)} checkpoints found (CP-*-N pattern)")
+        else:
+            result.warn(f"[{skill_name}] No checkpoint markers found")
+
+
+def run_r4(result: Result):
+    """R4: L4 Script Layer Light checks."""
+    print("\n=== R4: L4 Script Layer ===")
+
+    # 1. Shell scripts executable
+    for sh_file in sorted(DEV_PIPELINE_DIR.glob("*.sh")):
+        if os.access(sh_file, os.X_OK):
+            result.ok(f"[{sh_file.name}] Executable")
+        else:
+            result.fail(f"[{sh_file.name}] NOT executable")
+
+    # 2. Python scripts compile
+    scripts_dir = DEV_PIPELINE_DIR / "scripts"
+    if scripts_dir.exists():
+        for py_file in sorted(scripts_dir.glob("*.py")):
+            try:
+                subprocess.run(
+                    [sys.executable, "-m", "py_compile", str(py_file)],
+                    capture_output=True, text=True, timeout=10,
+                )
+                result.ok(f"[{py_file.name}] Compiles OK")
+            except subprocess.TimeoutExpired:
+                result.warn(f"[{py_file.name}] Compile check timed out")
+
+    # 3. Bash lib sourcing
+    for run_script in ["run-feature.sh", "run-bugfix.sh", "run-refactor.sh"]:
+        script_path = DEV_PIPELINE_DIR / run_script
+        if not script_path.exists():
+            result.fail(f"[{run_script}] NOT FOUND")
+            continue
+        content = script_path.read_text(encoding="utf-8")
+        for lib in ["common.sh", "heartbeat.sh", "branch.sh"]:
+            if lib in content:
+                result.ok(f"[{run_script}] Sources {lib}")
+            else:
+                result.fail(f"[{run_script}] Does NOT source {lib}")
+
+    # 4. JSON templates valid
+    templates_dir = DEV_PIPELINE_DIR / "templates"
+    if templates_dir.exists():
+        for json_file in sorted(templates_dir.glob("*.json")):
+            try:
+                json.loads(json_file.read_text())
+                result.ok(f"[{json_file.name}] Valid JSON")
+            except json.JSONDecodeError as e:
+                result.fail(f"[{json_file.name}] Invalid JSON: {e}")
+
+    # 5. Test file existence
+    tests_dir = DEV_PIPELINE_DIR / "tests"
+    if tests_dir.exists():
+        test_files = list(tests_dir.glob("test_*.py"))
+        if test_files:
+            result.ok(f"Test files found: {len(test_files)}")
+        else:
+            result.warn("No test_*.py files found in dev-pipeline/tests/")
+    else:
+        result.warn("dev-pipeline/tests/ directory not found")
+
+
+# --- Main ---
+
+def main():
+    parser = argparse.ArgumentParser(description="PrizmKit Light Verification")
+    parser.add_argument("--round", nargs="*", default=["R1", "R2", "R3", "R4"],
+                        help="Rounds to run (R1, R2, R3, R4)")
+    args = parser.parse_args()
+
+    rounds_to_run = [r.upper() for r in args.round]
+    result = Result()
+
+    round_map = {"R1": run_r1, "R2": run_r2, "R3": run_r3, "R4": run_r4}
+
+    for round_name in rounds_to_run:
+        if round_name in round_map:
+            round_map[round_name](result)
+        else:
+            print(f"  Unknown round: {round_name}")
+
+    # Print results
+    print("\n" + "=" * 60)
+    print(f"  RESULT: {result.status}")
+    print(f"  {result.summary()}")
+    print("=" * 60)
+
+    if result.failed > 0:
+        print("\n  FAILURES:")
+        for status, msg in result.details:
+            if status == "FAIL":
+                print(f"    {msg}")
+
+    if result.warned > 0:
+        print("\n  WARNINGS:")
+        for status, msg in result.details:
+            if status == "WARN":
+                print(f"    {msg}")
+
+    print()
+    return 0 if result.failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bundled/skills/recovery-workflow/SKILL.md

@@ -161,6 +161,7 @@ If the user declines, suggest alternatives:
 1. **Read the workflow's SKILL.md** from `core/skills/orchestration-skill/workflows/{workflow-type}/SKILL.md`
 2. **Read existing artifacts** to restore context — check in this order for the most efficient recovery:
    - If `session-summary.md` exists in the artifact directory → read it first. It provides a lightweight summary of completed tasks, key decisions, active TRAPS, and remaining work from the interrupted session.
+     > **Note**: `session-summary.md` is generated by the pipeline's bootstrap prompt system (`generate-bootstrap-prompt.py`) at the end of each AI CLI session. It may not exist if the session crashed before completion or if running in interactive (non-pipeline) mode. If absent, reconstruct context from the artifacts below.
    - Then read remaining artifacts: spec, plan, code diffs, bug descriptions, etc.
 3. **Read relevant `.prizm-docs/`** — load project context (L0 root, relevant L1). If `session-summary.md` was found, use its "Files Changed" section to focus L1/L2 loading on affected modules only.
 

package/bundled/skills/refactor-pipeline-launcher/SKILL.md

@@ -135,16 +135,20 @@ Detect user intent from their message, then follow the corresponding workflow:
 
    Use `AskUserQuestion` to present the following configuration choices. Each question is a separate selectable option:
 
-   **Question 1 — Verbose logging** (multiSelect: false):
+   **Question 1 — Critic review** (multiSelect: false):
+   - Off (default) — Skip adversarial review
+   - On — Enable critic review after refactoring (+3-8 min/refactor for critical/high complexity)
+
+   **Question 2 — Verbose logging** (multiSelect: false):
    - On (default) — Detailed AI session logs including tool calls and subagent activity
    - Off — Minimal logging
 
-   **Question 2 — Max retries** (multiSelect: false):
+   **Question 3 — Max retries** (multiSelect: false):
    - 3 (default)
    - 1
    - 5
 
-   **Question 3 — Session timeout** (multiSelect: false):
+   **Question 4 — Session timeout** (multiSelect: false):
    - None (default) — No timeout
    - 30 min — `SESSION_TIMEOUT=1800`
    - 1 hour — `SESSION_TIMEOUT=3600`

package/bundled/skills/refactor-planner/SKILL.md

@@ -302,7 +302,31 @@ If issues found, discuss with user and resolve before proceeding.
 - `type` field must be one of: `extract`, `rename`, `restructure`, `simplify`, `decouple`, `migrate`
 - Descriptions minimum 15 words (error). Recommended: 30/50/80 words for low/medium/high complexity (warning).
 - `model` field is optional — omitting it means the pipeline uses $MODEL env or CLI default
-- `scope` array lists target file/directory paths
+- `scope` object with nested structure: `files` array (target file paths) and `modules` array (module names)
+
+## Adversarial Critic Review
+
+All refactoring items support optional critic review for additional quality assurance. The critic mechanism helps validate that refactoring preserves behavior while improving code quality.
+
+### Default Critic Behavior
+
+| Priority | Complexity | `critic` | `critic_count` | Rationale |
+|----------|-----------|----------|----------------|-----------|
+| critical | high | `true` | `3` | Multi-critic voting for high-risk refactors |
+| critical | medium/low | `true` | `1` | Single critic for critical-priority refactors |
+| high | high | `true` | `1` | Single critic for high-complexity refactors |
+| high | medium/low | `false` | (omitted) | Skip critic for simpler high-priority items |
+| medium | any | `false` | (omitted) | Skip critic for medium-priority refactors |
+| low | any | `false` | (omitted) | Skip critic for low-priority refactors |
+
+- `critic: true` — Enable adversarial review after refactoring completion
+- `critic_count: 1` — Single critic agent reviews the refactor
+- `critic_count: 3` — Three critic agents vote on the refactor quality
+- Critic verifies: behavior preservation strategy followed, code quality improved, no regressions, tests passing
+
+**User Override**: During planning phases, users can opt to enable/disable critic on a per-item basis.
+
+---
 
 ## Fast Path
 
@@ -342,6 +366,32 @@ AI: [Validates immediately]
 AI: "Ready to proceed to dev-pipeline."
 ```
 
+## Browser Verification
+
+**Browser verification is a feature-pipeline capability only.** Refactors use `behavior_preservation` strategy instead to ensure no external behavior changes:
+
+- `strategy: test-gate` — Rely on existing test suite. Pipeline runs tests before and after refactoring.
+- `strategy: snapshot` — Compare behavior before/after refactoring using executable snapshots (outputs, API responses, side effects)
+- `strategy: manual` — Require human verification that behavior is preserved
+
+For refactors that modify UI code (e.g., component restructuring), the test-gate or snapshot strategy ensures visual appearance is preserved. You can optionally note browser verification needs in your description or acceptance criteria:
+
+Example:
+```
+Refactor Title: Extract UserProfile component from AccountSettings
+Type: extract
+Strategy: snapshot
+Acceptance Criteria:
+  1. UserProfile component renders identically to inline version (compare snapshots)
+  2. All props are correctly forwarded (unit tests pass)
+  3. No visual regression (screenshot comparison)
+  4. Component is reusable in other views
+```
+
+The refactor pipeline AI will use the snapshot strategy to verify external behavior is preserved during refactoring.
+
+---
+
 ## Refactoring-Specific Features
 
 ### Behavior Preservation Check

package/bundled/skills/refactor-workflow/SKILL.md

@@ -235,6 +235,8 @@ Present this summary to the user and get explicit confirmation before proceeding
    - Pass the structured goals summary as input — NOT the raw user conversation
    - For new refactoring: standard planning mode
    - For existing projects with `--incremental`: incremental planning mode
+   - **Input**: Markdown goals summary (refactor targets, scope, behavior preservation strategy)
+   - **Output**: `refactor-list.json` (schema: `dev-pipeline-refactor-list-v1`) containing `project_name`, `refactors[]` with id (R-NNN), title, description, scope, type, priority, complexity, behavior_preservation, acceptance_criteria, dependencies, status
 
 2. **Interactive planning** (if refactor-planner requires clarification):
    - Because Phase 1 was thorough, refactor-planner should need minimal clarification
@@ -267,9 +269,11 @@ Present this summary to the user and get explicit confirmation before proceeding
    ```
 
 2. **Invoke `refactor-pipeline-launcher` skill**:
+   - **Input**: Path to validated `refactor-list.json`
    - The launcher handles all prerequisites checks
    - The launcher presents execution mode choices to the user (foreground/background/manual)
    - Do NOT duplicate execution mode selection here — let the launcher handle it
+   - **Output**: PID/status, log file path, execution mode selected
    - Returns PID/status and log file location
 
 3. **Verify launch success**:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {

package/src/scaffold.js

@@ -414,7 +414,17 @@ export async function installSettings(platform, projectRoot, options, dryRun) {
       'Bash(jq *)',
     ];
     if (options.pipeline) {
-      permissions.push('Bash(./dev-pipeline/run-feature.sh *)', 'Bash(./dev-pipeline/launch-feature-daemon.sh *)');
+      // 动态扫描 pipeline 目录中的 .sh 入口脚本（run-*、launch-*），自动添加执行权限
+      const pipelineDir = getPipelineDir();
+      try {
+        const pipelineEntries = await fs.readdir(pipelineDir);
+        const entryScripts = pipelineEntries.filter(f => /^(run-|launch-|retry-|reset-).*\.sh$/.test(f));
+        for (const script of entryScripts) {
+          permissions.push(`Bash(./dev-pipeline/${script} *)`);
+        }
+      } catch {
+        // Fallback: if readdir fails, add no pipeline permissions
+      }
     }
 
     const settings = {
@@ -600,11 +610,15 @@ export function resolvePipelineFileList() {
   const pipelineSource = getPipelineDir();
   if (!pipelineSource || !fs.pathExistsSync(pipelineSource)) return [];
 
-  const items = [
-    'run-feature.sh', 'retry-feature.sh', 'reset-feature.sh', 'launch-feature-daemon.sh',
-    'run-bugfix.sh', 'retry-bugfix.sh', 'launch-bugfix-daemon.sh',
-    'lib', 'scripts', 'templates', 'assets', 'README.md', '.gitignore',
-  ];
+  // 动态扫描，与 installPipeline() 保持一致的排除规则
+  const EXCLUDE = new Set(['tests', 'docs', '__pycache__', 'node_modules', '.DS_Store']);
+  let allEntries;
+  try {
+    allEntries = fs.readdirSync(pipelineSource);
+  } catch {
+    return [];
+  }
+  const items = allEntries.filter(name => !EXCLUDE.has(name) && !name.startsWith('.'));
 
   const files = [];
   for (const item of items) {
@@ -636,12 +650,10 @@ export async function installPipeline(projectRoot, dryRun, { forceOverwrite = fa
   await fs.ensureDir(path.join(pipelineTarget, 'state'));
   await fs.ensureDir(path.join(pipelineTarget, 'bugfix-state'));
 
-  // 需要安装的 Pipeline 文件和目录
-  const items = [
-    'run-feature.sh', 'retry-feature.sh', 'reset-feature.sh', 'launch-feature-daemon.sh',
-    'run-bugfix.sh', 'retry-bugfix.sh', 'launch-bugfix-daemon.sh',
-    'lib', 'scripts', 'templates', 'assets', 'README.md', '.gitignore',
-  ];
+  // 动态扫描 bundled dev-pipeline 目录，排除不应安装到用户项目的内容
+  const EXCLUDE = new Set(['tests', 'docs', '__pycache__', 'node_modules', '.DS_Store']);
+  const allEntries = await fs.readdir(pipelineSource);
+  const items = allEntries.filter(name => !EXCLUDE.has(name) && !name.startsWith('.'));
 
   let installedCount = 0;
   const installedFiles = [];