@hanzlaa/rcode 3.6.16 → 4.1.0

package/rihal/skills/core/rihal-distillator/resources/distillate-format-reference.md

@@ -1,227 +0,0 @@
-# Distillate Format Reference
-
-Examples showing the transformation from human-readable source content to distillate format.
-
-## Frontmatter
-
-Every distillate includes YAML frontmatter. Source paths are relative to the distillate's location so the distillate remains portable:
-
-```yaml
----
-type: rihal-distillate
-sources:
-  - "product-brief-example.md"
-  - "product-brief-example-discovery-notes.md"
-downstream_consumer: "PRD creation"
-created: "2026-03-13"
-token_estimate: 1200
-parts: 1
----
-```
-
-## Before/After Examples
-
-### Prose Paragraph to Dense Bullet
-
-**Before** (human-readable brief excerpt):
-```
-## What Makes This Different
-
-**The anti-fragmentation layer.** The AI tooling space is fracturing across 40+
-platforms with no shared methodology layer. Rihal is uniquely positioned to be the
-cross-platform constant — the structured approach that works the same in Cursor,
-Claude Code, Windsurf, Copilot, and whatever launches next month. Every other
-methodology or skill framework maintains its own platform support matrix. By
-building on the open-source skills CLI ecosystem, Rihal offloads the highest-churn
-maintenance burden and focuses on what actually differentiates it: the methodology
-itself.
-```
-
-**After** (distillate):
-```
-## Differentiation
-- Anti-fragmentation positioning: Rihal = cross-platform constant across 40+ fragmenting AI tools; no competitor provides shared methodology layer
-- Platform complexity delegated to Vercel skills CLI ecosystem (MIT); Rihal maintains methodology, not platform configs
-```
-
-### Technical Details to Compressed Facts
-
-**Before** (discovery notes excerpt):
-```
-## Competitive Landscape
-
-- **Vercel Skills.sh**: 83K+ skills, 18 agents, largest curated leaderboard —
-  but dev-only, skills trigger unreliably (20% without explicit prompting)
-- **SkillsMP**: 400K+ skills directory, pure aggregator with no curation or CLI
-- **ClawHub/OpenClaw**: ~3.2K curated skills with versioning/rollback, small ecosystem
-- **Lindy**: No-code AI agent builder for business automation — closed platform,
-  no skill sharing
-- **Microsoft Copilot Studio**: Enterprise no-code agent builder — vendor-locked
-  to Microsoft
-- **MindStudio**: No-code AI agent platform — siloed, no interoperability
-- **Make/Zapier AI**: Workflow automation adding AI agents — workflow-centric,
-  not methodology-centric
-- **Key gap**: NO competitor combines structured methodology with plugin
-  marketplace — this is Rihal's whitespace
-```
-
-**After** (distillate):
-```
-## Competitive Landscape
-- No competitor combines structured methodology + plugin marketplace (whitespace)
-- Skills.sh (Vercel): 83K skills, 18 agents, dev-only, 20% trigger reliability
-- SkillsMP: 400K skills, aggregator only, no curation/CLI
-- ClawHub: 3.2K curated, versioning, small ecosystem
-- No-code platforms (Lindy, Copilot Studio, MindStudio, Make/Zapier): closed/siloed, no skill portability, business-only
-```
-
-### Deduplication Across Documents
-
-When the same fact appears in both a brief and discovery notes:
-
-**Brief says:**
-```
-The rihal-init utility lives in .rihal/skills/rihal-init/ — reference it via @.rihal/skills/rihal-init/SKILL.md in every bundle
-```
-
-**Discovery notes say:**
-```
-The rihal-init utility lives in .rihal/skills/rihal-init/ — reference it via @.rihal/skills/rihal-init/SKILL.md in every bundle/install
-(solves bootstrapping problem)
-```
-
-**Distillate keeps the more contextual version:**
-```
-- rihal-init: always included as base skill in every bundle (solves bootstrapping)
-```
-
-### Decision/Rationale Compression
-
-**Before:**
-```
-We decided not to build our own platform support matrix going forward, instead
-delegating to the Vercel skills CLI ecosystem. The rationale is that maintaining
-20+ platform configs is the biggest maintenance burden and it's unsustainable
-at 40+ platforms.
-```
-
-**After:**
-```
-- Rejected: own platform support matrix. Reason: unsustainable at 40+ platforms; delegate to Vercel CLI ecosystem
-```
-
-## Full Example
-
-A complete distillate produced from a product brief and its discovery notes, targeted at PRD creation:
-
-```markdown
----
-type: rihal-distillate
-sources:
-  - "product-brief-rihal-next-gen-installer.md"
-  - "product-brief-rihal-next-gen-installer-discovery-notes.md"
-downstream_consumer: "PRD creation"
-created: "2026-03-13"
-token_estimate: 1450
-parts: 1
----
-
-## Core Concept
-- Rihal Next-Gen Installer: replaces monolithic Node.js CLI with skill-based plugin architecture for distributing Rihal methodology across 40+ AI platforms
-- Three layers: self-describing plugins (rihal-manifest.json), cross-platform install via Vercel skills CLI (MIT), runtime registration via rihal-init (internal skill at .rihal/skills/rihal-init/)
-- Transforms Rihal from dev-only methodology into open platform for any domain (creative, therapeutic, educational, personal)
-
-## Problem
-- Current installer maintains ~20 platform configs manually; each platform convention change requires installer update, test, release — largest maintenance burden on team
-- Node.js/npm required — blocks non-technical users on UI-based platforms (Claude Co-Work, etc.)
-- CSV manifests are static, generated once at install; no runtime scanning/registration
-- Unsustainable at 40+ platforms; new tools launching weekly
-
-## Solution Architecture
-- Plugins: skill bundles with Anthropic plugin standard as base format + rihal-manifest.json extending for Rihal-specific metadata (installer options, capabilities, help integration, phase ordering, dependencies)
-- Existing manifest example: `{"module-code":"rihal","replaces-skill":"rihal-create-product-brief","capabilities":[{"name":"create-brief","menu-code":"CB","supports-headless":true,"phase-name":"1-analysis","after":["brainstorming"],"before":["create-prd"],"is-required":true}]}`
-- Vercel skills CLI handles platform translation; integration pattern (wrap/fork/call) is PRD decision
-- rihal-init: global skill scanning installed rihal-manifest.json files, registering capabilities, configuring project settings; always included as base skill in every bundle (solves bootstrapping)
-- rihal-update: plugin update path without full reinstall; technical approach (diff/replace/preserve customizations) is PRD decision
-- Distribution tiers: (1) NPX installer wrapping skills CLI for technical users, (2) zip bundle + platform-specific README for non-technical users, (3) future marketplace
-- Non-technical path has honest friction: "copy to right folder" requires knowing where; per-platform README instructions; improves over time as low-code space matures
-
-## Differentiation
-- Anti-fragmentation: Rihal = cross-platform constant; no competitor provides shared methodology layer across AI tools
-- Curated quality: all submissions gated, human-reviewed by Rihal + core team; 13.4% of community skills have critical vulnerabilities (Snyk 2026); quality gate value increases as ecosystem gets noisier
-- Domain-agnostic: no competitor builds beyond software dev workflows; same plugin system powers any domain via Rihal Builder (separate initiative)
-
-## Users (ordered by v1 priority)
-- Module authors (primary v1): package/test/distribute plugins independently without installer changes
-- Developers: single-command install on any of 40+ platforms via NPX
-- Non-technical users: install without Node/Git/terminal; emerging segment including PMs, designers, educators
-- Future plugin creators: non-dev authors using Rihal Builder; need distribution without building own installer
-
-## Success Criteria
-- Zero (or near-zero) custom platform directory code; delegated to skills CLI ecosystem
-- Installation verified on top platforms by volume; skills CLI handles long tail
-- Non-technical install path validated with non-developer users
-- rihal-init discovers/registers all plugins from manifests; clear errors for malformed manifests
-- At least one external module author successfully publishes plugin using manifest system
-- rihal-update works without full reinstall
-- Existing CLI users have documented migration path
-
-## Scope
-- In: manifest spec, rihal-init, rihal-update, Vercel CLI integration, NPX installer, zip bundles, migration path
-- Out: Rihal Builder, marketplace web platform, skill conversion (prerequisite, separate), one-click install for all platforms, monetization, quality certification process (gated-submission principle is architectural requirement; process defined separately)
-- Deferred: CI/CD integration, telemetry for module authors, air-gapped enterprise install, zip bundle integrity verification (checksums/signing), deeper non-technical platform integrations
-
-## Current Installer (migration context)
-- Entry: `tools/cli/rihal-cli.js` (Commander.js) → `tools/cli/installers/lib/core/installer.js`
-- Platforms: `platform-codes.yaml` (~20 platforms with target dirs, legacy dirs, template types, special flags)
-- Manifests: CSV files (skill/workflow/agent-manifest.csv) are current source of truth, not JSON
-- External modules: `external-official-modules.yaml` (CIS, GDS, TEA, WDS) from npm with semver
-- Dependencies: 4-pass resolver (collect → parse → resolve → transitive); YAML-declared only
-- Config: prompts for name, communication language, document output language, output folder
-- Skills already use directory-per-skill layout; rihal-manifest.json sidecars exist but are not source of truth
-- Key shift: CSV-based static manifests → JSON-based runtime scanning
-
-## Vercel Skills CLI
-- `npx skills add <source>` — GitHub, GitLab, local paths, git URLs
-- 40+ agents; per-agent path mappings; symlinks (recommended) or copies
-- Scopes: project-level or global
-- Discovery: `skills/`, `.agents/skills/`, agent-specific paths, `.claude-plugin/marketplace.json`
-- Commands: add, list, find, remove, check, update, init
-- Non-interactive: `-y`, `--all` flags for CI/CD
-
-## Competitive Landscape
-- No competitor combines structured methodology + plugin marketplace (whitespace)
-- Skills.sh (Vercel): 83K skills, dev-only, 20% trigger reliability without explicit prompting
-- SkillsMP: 400K skills, aggregator only, no curation
-- ClawHub: 3.2K curated, versioning, small
-- No-code platforms (Lindy, Copilot Studio, MindStudio, Make/Zapier): closed/siloed, no skill portability, business-only
-- Market: $7.84B (2025) → $52.62B (2030); Agent Skills spec ~4 months old, 351K+ skills; standards converging under Linux Foundation AAIF (MCP, AGENTS.md, A2A)
-
-## Rejected Alternatives
-- Building own platform support matrix: unsustainable at 40+; delegate to Vercel ecosystem
-- One-click install for non-technical v1: emerging space; guidance-based, improve over time
-- Prior roadmap/brainstorming: clean start, unconstrained by previous planning
-
-## Open Questions
-- Vercel CLI integration pattern: wrap/fork/call/peer dependency?
-- rihal-update mechanics: diff/replace? Preserve user customizations?
-- Migration story: command/manual reinstall/compatibility shim?
-- Cross-platform testing: CI matrix for top N? Community testing for rest?
-- rihal-manifest.json as open standard submission to Agent Skills governance?
-- Platforms NOT supported by Vercel skills CLI?
-- Manifest versioning strategy for backward compatibility?
-- Plugin author getting-started experience and tooling?
-
-## Opportunities
-- Module authors as acquisition channel: each published plugin distributes Rihal to creator's audience
-- CI/CD integration: rihal-init as pipeline one-liner increases stickiness
-- Educational institutions: structured methodology + non-technical install → university AI curriculum
-- Skill composability: mixing Rihal modules with third-party skills for custom methodology stacks
-
-## Risks
-- Manifest format evolution creates versioning/compatibility burden once third-party authors publish
-- Quality gate needs defined process, not just claim — gated review model addresses
-- 40+ platform testing environments even with Vercel handling translation
-- Scope creep pressure from marketplace vision (explicitly excluded but primary long-term value)
-- Vercel dependency: minor supply-chain risk; MIT license allows fork if deprioritized
-```

package/rihal/skills/core/rihal-distillator/scripts/analyze_sources.py

@@ -1,300 +0,0 @@
-# /// script
-# /// requires-python = ">=3.10"
-# /// dependencies = []
-# ///
-"""Analyze source documents for the distillation generator.
-
-Enumerates files from paths/folders/globs, computes sizes and token estimates,
-detects document types from naming conventions, and suggests groupings for
-related documents (e.g., a brief paired with its discovery notes).
-
-Accepts: file paths, folder paths (scans recursively for .md/.txt/.yaml/.yml/.json),
-or glob patterns. Skips node_modules, .git, __pycache__, .venv, .rihal.
-
-Output JSON structure:
-  status: "ok" | "error"
-  files[]: path, filename, size_bytes, estimated_tokens, doc_type
-  summary: total_files, total_size_bytes, total_estimated_tokens
-  groups[]: group_key, files[] with role (primary/companion/standalone)
-    - Groups related docs by naming convention (e.g., brief + discovery-notes)
-  routing: recommendation ("single" | "fan-out"), reason
-    - single: ≤3 files AND ≤15K estimated tokens
-    - fan-out: >3 files OR >15K estimated tokens
-  split_prediction: prediction ("likely" | "unlikely"), reason, estimated_distillate_tokens
-    - Estimates distillate at ~1/3 source size; splits if >5K tokens
-"""
-
-from __future__ import annotations
-
-import argparse
-import glob
-import json
-import os
-import re
-import sys
-from pathlib import Path
-
-# Extensions to include when scanning folders
-INCLUDE_EXTENSIONS = {".md", ".txt", ".yaml", ".yml", ".json"}
-
-# Directories to skip when scanning folders
-SKIP_DIRS = {
-    "node_modules", ".git", "__pycache__", ".venv", "venv",
-    ".claude", ".rihal", ".cursor", ".vscode",
-}
-
-# Approximate chars per token for estimation
-CHARS_PER_TOKEN = 4
-
-# Thresholds
-SINGLE_COMPRESSOR_MAX_TOKENS = 15_000
-SINGLE_DISTILLATE_MAX_TOKENS = 5_000
-
-# Naming patterns for document type detection
-DOC_TYPE_PATTERNS = [
-    (r"discovery[_-]notes", "discovery-notes"),
-    (r"product[_-]brief", "product-brief"),
-    (r"research[_-]report", "research-report"),
-    (r"architecture", "architecture-doc"),
-    (r"prd", "prd"),
-    (r"distillate", "distillate"),
-    (r"changelog", "changelog"),
-    (r"readme", "readme"),
-    (r"spec", "specification"),
-    (r"requirements", "requirements"),
-    (r"design[_-]doc", "design-doc"),
-    (r"meeting[_-]notes", "meeting-notes"),
-    (r"brainstorm", "brainstorming"),
-    (r"interview", "interview-notes"),
-]
-
-# Patterns for grouping related documents
-GROUP_PATTERNS = [
-    # base document + discovery notes
-    (r"^(.+?)(?:-discovery-notes|-discovery_notes)\.(\w+)$", r"\1.\2"),
-    # base document + appendix
-    (r"^(.+?)(?:-appendix|-addendum)(?:-\w+)?\.(\w+)$", r"\1.\2"),
-    # base document + review/feedback
-    (r"^(.+?)(?:-review|-feedback)\.(\w+)$", r"\1.\2"),
-]
-
-
-def resolve_inputs(inputs: list[str]) -> list[Path]:
-    """Resolve input arguments to a flat list of file paths."""
-    files: list[Path] = []
-    for inp in inputs:
-        path = Path(inp)
-        if path.is_file():
-            files.append(path.resolve())
-        elif path.is_dir():
-            for root, dirs, filenames in os.walk(path):
-                dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
-                for fn in sorted(filenames):
-                    fp = Path(root) / fn
-                    if fp.suffix.lower() in INCLUDE_EXTENSIONS:
-                        files.append(fp.resolve())
-        else:
-            # Try as glob
-            matches = glob.glob(inp, recursive=True)
-            for m in sorted(matches):
-                mp = Path(m)
-                if mp.is_file() and mp.suffix.lower() in INCLUDE_EXTENSIONS:
-                    files.append(mp.resolve())
-    # Deduplicate while preserving order
-    seen: set[Path] = set()
-    deduped: list[Path] = []
-    for f in files:
-        if f not in seen:
-            seen.add(f)
-            deduped.append(f)
-    return deduped
-
-
-def detect_doc_type(filename: str) -> str:
-    """Detect document type from filename."""
-    name_lower = filename.lower()
-    for pattern, doc_type in DOC_TYPE_PATTERNS:
-        if re.search(pattern, name_lower):
-            return doc_type
-    return "unknown"
-
-
-def suggest_groups(files: list[Path]) -> list[dict]:
-    """Suggest document groupings based on naming conventions."""
-    groups: dict[str, list[dict]] = {}
-    ungrouped: list[dict] = []
-
-    file_map = {f.name: f for f in files}
-
-    assigned: set[str] = set()
-
-    for f in files:
-        if f.name in assigned:
-            continue
-
-        matched = False
-        for pattern, base_pattern in GROUP_PATTERNS:
-            m = re.match(pattern, f.name, re.IGNORECASE)
-            if m:
-                # This file is a companion — find its base
-                base_name = re.sub(pattern, base_pattern, f.name, flags=re.IGNORECASE)
-                group_key = base_name
-                if group_key not in groups:
-                    groups[group_key] = []
-                    # Add the base file if it exists
-                    if base_name in file_map and base_name not in assigned:
-                        groups[group_key].append({
-                            "path": str(file_map[base_name]),
-                            "filename": base_name,
-                            "role": "primary",
-                        })
-                        assigned.add(base_name)
-                groups[group_key].append({
-                    "path": str(f),
-                    "filename": f.name,
-                    "role": "companion",
-                })
-                assigned.add(f.name)
-                matched = True
-                break
-
-        if not matched:
-            # Check if this file is a base that already has companions
-            if f.name in groups:
-                continue  # Already added as primary
-            ungrouped.append({
-                "path": str(f),
-                "filename": f.name,
-            })
-
-    result = []
-    for group_key, members in groups.items():
-        result.append({
-            "group_key": group_key,
-            "files": members,
-        })
-    for ug in ungrouped:
-        if ug["filename"] not in assigned:
-            result.append({
-                "group_key": ug["filename"],
-                "files": [{"path": ug["path"], "filename": ug["filename"], "role": "standalone"}],
-            })
-
-    return result
-
-
-def analyze(inputs: list[str], output_path: str | None = None) -> None:
-    """Main analysis function."""
-    files = resolve_inputs(inputs)
-
-    if not files:
-        result = {
-            "status": "error",
-            "error": "No readable files found from provided inputs",
-            "inputs": inputs,
-        }
-        output_json(result, output_path)
-        return
-
-    # Analyze each file
-    file_details = []
-    total_chars = 0
-    for f in files:
-        size = f.stat().st_size
-        total_chars += size
-        file_details.append({
-            "path": str(f),
-            "filename": f.name,
-            "size_bytes": size,
-            "estimated_tokens": size // CHARS_PER_TOKEN,
-            "doc_type": detect_doc_type(f.name),
-        })
-
-    total_tokens = total_chars // CHARS_PER_TOKEN
-    groups = suggest_groups(files)
-
-    # Routing recommendation
-    if len(files) <= 3 and total_tokens <= SINGLE_COMPRESSOR_MAX_TOKENS:
-        routing = "single"
-        routing_reason = (
-            f"{len(files)} file(s), ~{total_tokens:,} estimated tokens — "
-            f"within single compressor threshold"
-        )
-    else:
-        routing = "fan-out"
-        routing_reason = (
-            f"{len(files)} file(s), ~{total_tokens:,} estimated tokens — "
-            f"exceeds single compressor threshold "
-            f"({'>' + str(SINGLE_COMPRESSOR_MAX_TOKENS) + ' tokens' if total_tokens > SINGLE_COMPRESSOR_MAX_TOKENS else '> 3 files'})"
-        )
-
-    # Split prediction
-    estimated_distillate_tokens = total_tokens // 3  # rough: distillate is ~1/3 of source
-    if estimated_distillate_tokens > SINGLE_DISTILLATE_MAX_TOKENS:
-        split_prediction = "likely"
-        split_reason = (
-            f"Estimated distillate ~{estimated_distillate_tokens:,} tokens "
-            f"exceeds {SINGLE_DISTILLATE_MAX_TOKENS:,} threshold"
-        )
-    else:
-        split_prediction = "unlikely"
-        split_reason = (
-            f"Estimated distillate ~{estimated_distillate_tokens:,} tokens "
-            f"within {SINGLE_DISTILLATE_MAX_TOKENS:,} threshold"
-        )
-
-    result = {
-        "status": "ok",
-        "files": file_details,
-        "summary": {
-            "total_files": len(files),
-            "total_size_bytes": total_chars,
-            "total_estimated_tokens": total_tokens,
-        },
-        "groups": groups,
-        "routing": {
-            "recommendation": routing,
-            "reason": routing_reason,
-        },
-        "split_prediction": {
-            "prediction": split_prediction,
-            "reason": split_reason,
-            "estimated_distillate_tokens": estimated_distillate_tokens,
-        },
-    }
-
-    output_json(result, output_path)
-
-
-def output_json(data: dict, output_path: str | None) -> None:
-    """Write JSON to file or stdout."""
-    json_str = json.dumps(data, indent=2)
-    if output_path:
-        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
-        Path(output_path).write_text(json_str + "\n")
-        print(f"Results written to {output_path}", file=sys.stderr)
-    else:
-        print(json_str)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description=__doc__,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument(
-        "inputs",
-        nargs="+",
-        help="File paths, folder paths, or glob patterns to analyze",
-    )
-    parser.add_argument(
-        "-o", "--output",
-        help="Output JSON to file instead of stdout",
-    )
-    args = parser.parse_args()
-    analyze(args.inputs, args.output)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/rihal/skills/core/rihal-editorial-review-prose/SKILL.md

@@ -1,127 +0,0 @@
----
-name: rihal-editorial-review-prose
-description: "Clinical copy-editor that reviews text for communication issues."
-triggers:
-  - "editorial review prose"
----
-@.rihal/references/karpathy-guidelines.md
-
-
-# Editorial Review - Prose
-
-**Goal:** Review text for communication issues that impede comprehension and output suggested fixes in a three-column table.
-
-**Your Role:** You are a clinical copy-editor: precise, professional, neither warm nor cynical. Apply Microsoft Writing Style Guide principles as your baseline. Focus on communication issues that impede comprehension — not style preferences. NEVER rewrite for preference — only fix genuine issues. Follow ALL steps in the STEPS section IN EXACT ORDER. DO NOT skip steps or change the sequence. HALT immediately when halt-conditions are met. Each action within a step is a REQUIRED action to complete that step.
-
-**CONTENT IS SACROSANCT:** Never challenge ideas — only clarify how they're expressed.
-
-**Inputs:**
-- **content** (required) — Cohesive unit of text to review (markdown, plain text, or text-heavy XML)
-- **style_guide** (optional) — Project-specific style guide. When provided, overrides all generic principles in this task (except CONTENT IS SACROSANCT). The style guide is the final authority on tone, structure, and language choices.
-- **reader_type** (optional, default: `humans`) — `humans` for standard editorial, `llm` for precision focus
-
-
-## Overview
-
-Editorial review prose skill for Rihal Code.
-
-## PRINCIPLES
-
-1. **Minimal intervention:** Apply the smallest fix that achieves clarity
-2. **Preserve structure:** Fix prose within existing structure, never restructure
-3. **Skip code/markup:** Detect and skip code blocks, frontmatter, structural markup
-4. **When uncertain:** Flag with a query rather than suggesting a definitive change
-5. **Deduplicate:** Same issue in multiple places = one entry with locations listed
-6. **No conflicts:** Merge overlapping fixes into single entries
-7. **Respect author voice:** Preserve intentional stylistic choices
-
-> **STYLE GUIDE OVERRIDE:** If a style_guide input is provided, it overrides ALL generic principles in this task (including the Microsoft Writing Style Guide baseline and reader_type-specific priorities). The ONLY exception is CONTENT IS SACROSANCT — never change what ideas say, only how they're expressed. When style guide conflicts with this task, style guide wins.
-
-
-## STEPS
-
-### Step 1: Validate Input
-
-- Check if content is empty or contains fewer than 3 words
-  - If empty or fewer than 3 words: **HALT** with error: "Content too short for editorial review (minimum 3 words required)"
-- Validate reader_type is `humans` or `llm` (or not provided, defaulting to `humans`)
-  - If reader_type is invalid: **HALT** with error: "Invalid reader_type. Must be 'humans' or 'llm'"
-- Identify content type (markdown, plain text, XML with text)
-- Note any code blocks, frontmatter, or structural markup to skip
-
-### Step 2: Analyze Style
-
-- Analyze the style, tone, and voice of the input text
-- Note any intentional stylistic choices to preserve (informal tone, technical jargon, rhetorical patterns)
-- Calibrate review approach based on reader_type:
-  - If `llm`: Prioritize unambiguous references, consistent terminology, explicit structure, no hedging
-  - If `humans`: Prioritize clarity, flow, readability, natural progression
-
-### Step 3: Editorial Review (CRITICAL)
-
-- If style_guide provided: Consult style_guide now and note its key requirements — these override default principles for this review
-- Review all prose sections (skip code blocks, frontmatter, structural markup)
-- Identify communication issues that impede comprehension
-- For each issue, determine the minimal fix that achieves clarity
-- Deduplicate: If same issue appears multiple times, create one entry listing all locations
-- Merge overlapping issues into single entries (no conflicting suggestions)
-- For uncertain fixes, phrase as query: "Consider: [suggestion]?" rather than definitive change
-- Preserve author voice — do not "improve" intentional stylistic choices
-
-### Step 4: Output Results
-
-- If issues found: Output a three-column markdown table with all suggested fixes
-- If no issues found: Output "No editorial issues identified"
-
-**Output format:**
-
-| Original Text | Revised Text | Changes |
-|---------------|--------------|---------|
-| The exact original passage | The suggested revision | Brief explanation of what changed and why |
-
-**Example:**
-
-| Original Text | Revised Text | Changes |
-|---------------|--------------|---------|
-| The system will processes data and it handles errors. | The system processes data and handles errors. | Fixed subject-verb agreement ("will processes" to "processes"); removed redundant "it" |
-| Users can chose from options (lines 12, 45, 78) | Users can choose from options | Fixed spelling: "chose" to "choose" (appears in 3 locations) |
-
-
-## HALT CONDITIONS
-
-- HALT with error if content is empty or fewer than 3 words
-- HALT with error if reader_type is not `humans` or `llm`
-- If no issues found after thorough review, output "No editorial issues identified" (this is valid completion, not an error)
-
-## Output Format
-
-Three-column markdown table:
-
-| Original Text | Revised Text | Changes |
-|---------------|--------------|---------|}
-| The exact original passage | The suggested revision | Brief explanation |
-
-## Workflow
-
-1. Read the user request and extract key parameters.
-2. Execute the skill logic as described in the Overview.
-3. Return output in the format specified below.
-
-## Examples
-
-### Happy path
-**User:** "review for prose" + pastes a PRD section
-**Result:** Table with 5 fixes — subject-verb agreement, redundant pronoun, ambiguous antecedent, passive voice, spelling
-
-### Edge case
-**User:** "review for prose" + perfect text
-**Result:** "No editorial issues identified"
-
-### Negative boundary
-**User:** "restructure this document"
-**Result:** Not prose review → route to `rihal-editorial-review-structure`
-
-## Memory Bank Hooks
-
-- **Reads:** the document under review; `style_guide` if provided
-- **Writes:** nothing — produces a recommendations report only