@neikyun/ciel 6.3.0 → 6.4.1

package/assets/platforms/opencode/.opencode/agents/ciel.md

@@ -33,7 +33,7 @@ Tu es l'orchestrateur Ciel v6. Analyse, planifie, implemente, verifie.
 
 ## Regles (immutables)
 
-1. **Depth en 1ere ligne** — chaque reponse commence par la classification (Trivial/Standard/Critical/Spike)
+1. **Pipeline interne** — classifie la profondeur et suis les 16 étapes en interne. N'affiche pas la classification.
 2. **Pipeline** — suis les 16 etapes (tableau ci-dessous). Le plugin injecte un rappel avant chaque message.
 3. **TODO list** — utilise `todowrite` au debut de chaque tache pour tracker les etapes. Marque chaque etape completed/in_progress au fur et a mesure.
 4. **ASK** — utilise `question` tool SEULEMENT si ambigu. Si le contexte est suffisant, DECIDE et avance. Ne demande pas pour chaque etape.

package/assets/platforms/opencode/.opencode/commands/ciel-audit.md

@@ -1,19 +1,309 @@
 ---
-command: ciel-audit
-description: Session post-mortem — detect Ciel paradigm violations
+description: ---
 subtask: false
 ---
 
-# /ciel-audit — Session audit
+---
+description: Audits the current Claude Code session for Ciel paradigm violations (missed Task dispatches, inline gathering, hook inactivity, skill overlaps, intent routing misses). Produces a structured report with a Ciel Health Score (0-100). If score < 75, creates a GitHub Issue on the Ciel repository with the findings and session timeline. Hook-independent — works even when Ciel hooks are broken.
+---
 
-Audits the current session for Ciel paradigm violations (missed pipeline steps, missing depth classification, skipped FAIRE gates, hook inactivity). Produces a structured report.
+# /ciel-audit — Session post-mortem
+
+*Generates a structured report of Ciel behavior violations observed in the current session. Calculates a Ciel Health Score (0-100). If the score is below 75, creates a GitHub Issue on the Ciel repository (github.com/KaosKyun/Ciel) with the full timeline and findings — otherwise produces the report only without creating an issue.*
 
 Usage: `/ciel-audit`
 
-## Process
+Runs inline in the main session. Does not dispatch agents. Does not depend on hooks being active.
+
+---
+
+## Instructions to the model
+
+You are auditing the **current conversation session** — the one you are participating in right now. Jump directly to the analysis. No preamble. No meta-commentary. No "I will now audit…".
+
+### What to audit
+
+Scan the session's tool-use history (your own prior turns). For each `/ciel <task>` invocation in this session, check the **eight dimensions** below. For each dimension, assign a severity and penalty score to calculate the final Ciel Health Score.
+
+#### Dimension 1: Dispatch discipline (critical) — penalty up to -25
+
+- Did the assistant emit a `Task(subagent_type="ciel-*")` within the **first 3 tool calls** after the `/ciel` prompt?
+- If NO: count the inline `Bash` / `Read` / `Grep` / `Glob` / `WebSearch` / `WebFetch` calls emitted in the main session before any dispatch. This is the v2.1.5 anti-pattern documented in `skills/ciel/SKILL.md:146-156`.
+- Exception: Trivial tasks (rename, typo, 1-line fix, docs-only) are allowed to run inline.
+- Severity→score:
+  - Critical dispatch violation (Standard/Critical task with no Task()): **-25**
+  - High (delayed dispatch, >1 inline tool before dispatch): **-15**
+  - OK (Task() within first 3 tool calls): **0**
+
+#### Dimension 2: Hook activity (critical) — penalty up to -25
+
+Search the session transcript for strings that Ciel hooks would have injected:
+
+- `"CIEL depth hint:"` — from `hooks/user-prompt-submit.sh:36`, injected via `additionalContext` on every UserPromptSubmit.
+- `"CIEL "` prefix (e.g., `"CIEL [CRITIQUE]"`, `"CIEL src/...` ) — from `hooks/pre-tool-write.sh:34,36`, injected before every Write/Edit.
+- Session banner from `hooks/session-start.sh` (SessionStart context).
+- `"META-CRITIQUER"` or similar end-of-session signal from `hooks/stop.sh`.
+
+- None found despite writes/edits: **-25** → hooks broken
+- Partial (some hooks firing but not all): **-10**
+- All present: **0**
+
+Most likely root cause: relative paths in `Ciel/settings.json:8,19,31,42,54,65,76`. The `command` field is written as `bash .claude/plugins/ciel/hooks/<file>.sh`, which Claude Code resolves against the current working directory, not the plugin directory.
+
+#### Dimension 3: Skill invocation coverage vs depth — penalty up to -15
+
+Cross-reference `skills/ciel/SKILL.md:20-64` (Depth Gauge) with what actually happened:
+
+- **Standard** task → `researcher` and `explorer` agents must be dispatched in parallel before FAIRE. Missing both: **-15**. Missing one: **-8**.
+- **Critical** task → must additionally invoke `stride-analyzer` and `security-regression-check`. Missing: **-15**.
+- Depth ambiguous and `depth-classifier` not invoked: **-5**.
+
+#### Dimension 4: Skill overlap / redundancy — penalty up to -10
+
+- Both `relire-critic` AND `critiquer-auditor` on the same diff: **-10**
+- `meta-critiquer` did not fire at end-of-task: **-5**
+- Same skill invoked 3+ times for same scope: **-5**
+
+#### Dimension 5: Agent report quality — penalty up to -5
+
+- Any `Task(subagent_type="ciel-*")` with returned message under 200 tokens: **-5** per occurrence (max -10)
+
+#### Dimension 6: Intent routing hits / misses — penalty up to -10
+
+Scan the user's `/ciel` prompt text against the intent signals in `SKILL.md:79-94`. For each matched intent, verify the corresponding skill was invoked. Each miss: **-5** (max -10).
+
+#### Dimension 7: npm version staleness — penalty up to -10
+
+Check if a newer version of Ciel is available on npm:
+
+```bash
+NPM_VERSION=$(npm view @neikyun/ciel version 2>/dev/null || echo "unknown")
+LOCAL_VERSION=$(cat /path/to/VERSION 2>/dev/null || cat package.json 2>/dev/null | grep '"version"' | head -1 | cut -d'"' -f4 || echo "unknown")
+```
+
+- npm version > local version: **-10**
+- Version check failed (npm not installed, no network): **0** (not a violation, just incomplete data)
+- Versions match or local is newer: **0**
+
+If npm version > local version, include an **Update notification** in the report:
+> A newer version of Ciel is available on npm: **{npm_version}** (installed: **{local_version}**). Run `ciel-update` or `npm update -g @neikyun/ciel` to upgrade.
+
+#### Dimension 8: Platform health — penalty up to -5
+
+Check which Ciel platforms are present and whether they have valid configurations:
+
+```bash
+ls /path/to/platforms/ 2>/dev/null
+```
+
+Expected platforms: codex, cursor, kilocode, lmstudio, ollama, opencode, windsurf
+
+- All platforms present: **0**
+- Missing 1-2 platforms: **-3**
+- Missing 3+ platforms: **-5**
+
+---
+
+### Scoring
+
+**Ciel Health Score** = 100 - sum(penalties)
+
+| Score range | Status | Issue created? |
+|-------------|--------|----------------|
+| 90-100 | Excellent | No |
+| 75-89 | Good (minor issues) | No |
+| 50-74 | Needs improvement | **Yes** — creates issue with timeline |
+| 0-49 | Critical | **Yes** — creates issue with timeline |
+
+The score is calculated automatically from the detected violations.
+
+---
+
+### Report format
+
+Begin the output with the literal line `# Ciel Session Audit Report`. End with the literal line `**End of audit report.**` on its own line.
+
+```markdown
+# Ciel Session Audit Report
+
+**Date**: <today's date>
+**Ciel Health Score**: <N>/100 — <Excellent|Good|Needs improvement|Critical>
+**npm**: local v<X.Y.Z> | npm v<X.Y.Z> | <up-to-date|update available>
+**Platforms**: codex ✓ cursor ✓ kilo ✓ lmstudio ✓ ollama ✓ opencode ✓ windsurf ✓ (or ✗ if missing)
+**Session summary**: <N> /ciel invocation(s), <N> total tool calls, <N> Task() dispatches, <N> inline Bash/Read/Grep/WebSearch calls in main session.
+
+**Verdict**: <PASS | VIOLATIONS FOUND>
+
+---
+
+## Violations detected
+
+### <N>. <Short violation name> — penalty: -<N>
+
+**Severity**: <critical | high | medium | low>
+**Evidence from session**
+- User prompt (turn N): `<exact prompt text, truncated to 200 chars>`
+- Assistant's first 3 tool calls after this prompt:
+  1. `<tool_name>(<brief args>)`
+  2. `<tool_name>(<brief args>)`
+  3. `<tool_name>(<brief args>)`
+- Expected: `Task(subagent_type="ciel-<role>", ...)` as first tool call
+- Observed: `<actual behavior>`
+
+**Root cause hypothesis**
+<one or two sentences>
+
+**Proposed fix**
+- <concrete edit with file:line>
+
+...
+
+---
+
+## Update notification
+
+<If npm version > local version, show update notification here. Otherwise omit this section.>
+
+---
+
+## Scoring breakdown
+
+| Dimension | Penalty |
+|-----------|---------|
+| D1 — Dispatch discipline | -<N> |
+| D2 — Hook activity | -<N> |
+| D3 — Skill coverage vs depth | -<N> |
+| D4 — Skill overlap | -<N> |
+| D5 — Agent report quality | -<N> |
+| D6 — Intent routing | -<N> |
+| D7 — npm version | -<N> |
+| D8 — Platform health | -<N> |
+| **Total** | **-<N>** |
+| **Health Score** | **<N>/100** |
+
+---
+
+## Summary of fixes to apply
+
+Apply these in order. Each points to a file:line and a concrete change.
+
+1. **<Fix name>** — `<path>:<line>` — <one-line description>
+2. ...
+
+After each fix: re-run the scenario that triggered the violation in a fresh Claude session to verify.
+
+---
+
+**End of audit report.**
+```
+
+### If no violations are found (score = 100)
+
+Output a single short section — **no issue is created** for PASS verdicts:
+
+```markdown
+# Ciel Session Audit Report
+
+**Date**: <today's date>
+**Ciel Health Score**: 100/100 — Excellent
+**npm**: local v<X.Y.Z> | npm v<X.Y.Z> | up-to-date
+**Platforms**: all 7 platforms present ✓
+**Session summary**: <N> /ciel invocation(s), <N> tool calls, <N> Task() dispatches.
+**Verdict**: PASS
+
+**No violations found.** No issue created.
+
+**End of audit report.**
+```
+
+---
+
+### GitHub Issue creation (only if score < 75)
+
+If the Ciel Health Score is **below 75**, create a GitHub Issue with the report AND the session timeline.
+
+**Important**: Do NOT create an issue if score >= 75. Only create for scores < 75.
+
+1. **Check for duplicate issues first**:
+   ```bash
+   EXISTING=$(gh issue list --repo KaosKyun/Ciel --label audit --state open \
+     --json title --jq '.[].title' 2>/dev/null | \
+     grep -c "^\[CIEL-AUDIT\] $(date +%Y-%m-%d) -" || true)
+   if [ "$EXISTING" -gt 0 ]; then
+     echo "Warning: today's audit issue already exists. Skipping creation."
+     echo "View existing at: https://github.com/KaosKyun/Ciel/issues?q=is%3Aopen+label%3Aaudit"
+     exit 0
+   fi
+   ```
+
+2. **Save the report to a temp file**: Write the complete report text to a temp file:
+   ```bash
+   REPORT_FILE="/tmp/ciel-audit-report-$(date +%Y%m%d).md"
+   cat > "$REPORT_FILE" << 'REPORT_EOF'
+   # Ciel Session Audit Report
+   ...
+   **End of audit report.**
+   REPORT_EOF
+   ```
+
+3. **Determine the repository**: run `gh repo view --json owner,name` to confirm, or default to `KaosKyun/Ciel`.
+
+4. **Create the issue** with `gh issue create`, using Python to avoid shell quoting issues:
+   ```bash
+   python3 -c "
+   import subprocess, sys
+   ymd, date_str, score, verdict = sys.argv[1:5]
+   report_path = f'/tmp/ciel-audit-report-{ymd}.md'
+   with open(report_path) as f:
+       body = f.read()
+   subprocess.run(['gh', 'issue', 'create',
+       '--repo', 'KaosKyun/Ciel',
+       '--title', f'[CIEL-AUDIT] {date_str} - {verdict} (Score: {score}/100)',
+       '--label', 'audit,ciel',
+       '--body', body])
+   " "$(date +%Y%m%d)" "$(date +%Y-%m-%d)" "<score>" "<verdict>"
+   ```
+
+5. **Include the session timeline** in the issue body. Before the report, add a timeline section listing all `/ciel` invocations in chronological order:
+   ```markdown
+   ## Session Timeline
+   
+   | Time | Event |
+   |------|-------|
+   | T+N  | /ciel <prompt excerpt> |
+   | T+N  | Write/Edit on <file> |
+   | T+N  | Task() dispatch to <agent> |
+   ...
+   
+   ---
+   
+   <full audit report>
+   ```
+
+6. **Handle errors gracefully**:
+   - If `gh` is not available: print a message telling the user to install (`brew install gh`) and print the report to stdout instead.
+   - If the repository can't be reached: skip issue creation, print a warning, but still output the report.
+
+7. **After creating the issue**: include the issue URL at the end of your response so the user can open it directly.
+
+**Title format**: `[CIEL-AUDIT] YYYY-MM-DD - VIOLATIONS FOUND (Score: <N>/100)`
+
+**Labels**: `audit`, `ciel`
+
+---
+
+### Tone and length
+
+- **Mechanically actionable, not narrative**. File paths, line numbers, before/after snippets.
+- Target length: 400–800 lines of markdown for a session with 2–3 violations. Shorter if PASS.
+- No rhetorical preamble. No meta-commentary about the audit process itself. No emoji. No closing remarks after the `**End of audit report.**` marker.
+
+### What NOT to do
 
-1. Analyzes current session context
-2. Checks for depth classification at each step
-3. Detects FAIRE gate violations
-4. Checks hook activity
-5. Reports findings with severity levels
+- Do NOT fix violations in the current session. Only produce the report and optionally create the issue.
+- Do NOT invoke other Ciel skills. This command is fully self-contained.
+- Do NOT dispatch `Task()` agents. Audit happens inline.
+- Do NOT ask clarifying questions. Produce the report with the information you have.
+- Do NOT create an issue if score >= 75. Only create for score < 75.
+- Do NOT create duplicate issues — run the `gh issue list` check before creating.
+- Do NOT restart, rerun, or attempt to fix the session in-flight. The audit report is the deliverable.

package/assets/platforms/opencode/.opencode/commands/ciel-create-skill.md

@@ -1,20 +1,85 @@
 ---
-command: ciel-create-skill
-description: Generate a new Ciel SKILL.md scaffold
+description: ---
 agent: ciel-improver
 subtask: true
 ---
 
-# /ciel-create-skill — Create new skill
+> **OpenCode note**: This command requires `claude --print` headless mode for full functionality (binary evals, skill scaffold generation). On OpenCode it runs in degraded mode — the improver agent returns proposals only. For the full harness, use Claude Code.
 
-Generates a valid Ciel SKILL.md scaffold following Anthropic Skills-first rules (kebab-case ≤64, YAML description ≤1024, body ≤500 lines).
+---
+description: Generates a valid Ciel SKILL.md scaffold following Anthropic Skills-first rules (kebab-case ≤64, YAML description ≤1024, body ≤500 lines).
+---
+
+# /ciel-create-skill — Create a new Ciel skill
+
+*Generates a valid SKILL.md scaffold following Anthropic Skills-first rules (kebab-case name ≤64 chars, YAML frontmatter ≤1024-char description, ≤500-line body, progressive disclosure to one reference.md).*
 
 Usage: `/ciel-create-skill <name> <purpose>`
 
-## Process
+- `name` — kebab-case, max 64 chars, unique across `skills/`
+- `purpose` — one-line description of what the skill does
+
+---
+
+## What it does
+
+1. Dispatches the `improver` agent in MODE=CREATE-SKILL
+2. The agent invokes `skill-creator` skill
+3. Validates name, category (you pick), description length, uniqueness, paths glob
+4. Generates a scaffold SKILL.md + optional reference.md
+5. Returns the proposed files for user review
+6. On approval, writes files + registers in `skills/ciel/reference.md` catalog
+
+---
+
+## Example
+
+```
+/ciel-create-skill kotlin-coroutines-mastery "Expert in Kotlin coroutines: structured concurrency, Flow operators, cancellation, testing. Use when working with suspend functions, CoroutineScope, Flow, or coroutine builders."
+```
+
+Expected output:
+1. Validation: ✓ name valid, unique, no reserved words
+2. Category suggestion: `domain` (based on "Expert in X" pattern)
+3. Preview of `skills/domain/kotlin-coroutines-mastery/SKILL.md` (~150 lines)
+4. Preview of `skills/domain/kotlin-coroutines-mastery/reference.md` (~300 lines) with Flow operators cheatsheet
+5. Catalog entry: `| kotlin-coroutines-mastery | Kotlin files with suspend/Flow |`
+6. Approve? [y/n/edit]
+
+---
+
+## Naming rules
+
+- kebab-case only (no underscores, no camelCase)
+- Max 64 chars
+- No reserved words: `anthropic`, `claude`, `mcp`
+- Must be unique across `skills/**/SKILL.md`
+- Warn if starts with category name (e.g. `workflow-foo` in `workflow/` is redundant)
+
+---
+
+## Category decision
+
+- `workflow` — enforces a CRÉER/CRITIQUER/META-CRITIQUER step
+- `research` — finds information outside the codebase
+- `domain` — encodes expertise in a specific tech or pattern family
+- `utility` — wraps a frequent mechanical operation
+- `meta` — modifies Ciel itself
+
+---
+
+## Guardrails
+
+- **Max 1 new skill per invocation** — prevents skill explosion
+- **SKILL.md size**: ≤ 300 lines (hard cap)
+- **reference.md size**: ≤ 500 lines (hard cap)
+- **Duplication detection**: warns if description overlaps ≥ 70% with existing skill
+- **Never creates**: files in `.claude-plugin/`, agents, hooks, commands — those use different patterns
+
+---
+
+## After creation
 
-1. Validates skill name (kebab-case, ≤64 chars)
-2. Researches common patterns for the domain
-3. Generates SKILL.md with YAML frontmatter
-4. Returns proposed skill for user approval
-5. Never writes autonomously
+1. Test the skill: `/ciel-eval <name>` (runs baseline eval if dataset exists)
+2. If it's a `workflow` skill, update `skills/ciel/SKILL.md` pipeline sections to reference it
+3. Commit with message `feat(ciel): add <category>/<name> skill`

package/assets/platforms/opencode/.opencode/commands/ciel-eval.md

@@ -1,27 +1,88 @@
 ---
-command: ciel-eval
-description: Run binary eval harness for Ciel skills
+description: ---
 agent: ciel-improver
 subtask: true
 ---
 
+> **OpenCode note**: This command requires `claude --print` headless mode for full functionality (binary evals, skill scaffold generation). On OpenCode it runs in degraded mode — the improver agent returns proposals only. For the full harness, use Claude Code.
+
+---
+description: Runs the binary eval dataset for one or all Ciel skills via claude --print headless, comparing variants.
+---
+
 # /ciel-eval — Run eval harness
 
-Runs the binary eval dataset for one skill (or all skills), comparing variants and persisting scoreboards.
+*Runs the binary eval dataset for one skill (or all skills) via `claude --print` headless mode, comparing variants and persisting scoreboards.*
 
 Usage: `/ciel-eval [skill-name]`
 
 - No arg → runs baseline eval for ALL skills that have a dataset
 - `skill-name` → runs eval for that skill only (baseline + any variants in `variants/`)
 
-## Process
+---
+
+## What it does
 
 1. Dispatches the `improver` agent in MODE=EVAL
 2. The agent invokes `skill-variant-evaluator` skill
 3. For each target skill:
-   - Loads dataset from `evals/datasets/<skill>.jsonl`
-   - Generates 2-3 variants of the skill
-   - Executes all variants headlessly against the dataset
-   - Compares aggregate scores
-   - Proposes winner with tiebreak on token usage
-4. Results appended to `evals/results/<skill>-scoreboard.md`
+   - Loads dataset from `evals/datasets/<skill-name>.jsonl`
+   - If variants exist (`skills/<category>/<name>/variants/*.md`), evaluates each
+   - Otherwise, baseline-only scoring
+4. Persists results to `evals/results/<skill-name>-<timestamp>.json`
+5. Returns a scoreboard
+
+---
+
+## Example output
+
+```
+# Eval results — flux-narrator
+
+Dataset: evals/datasets/flux-narration.jsonl (8 entries)
+Variants evaluated: 3
+
+| Variant | Score | Tokens | Duration |
+|---------|-------|--------|----------|
+| A (baseline) | 0.72 | 14.5k | 12.5s |
+| B (tightened) | 0.89 | 15.1k | 13.2s ← WINNER |
+| C (reduced) | 0.81 | 12.8k | 11.7s |
+
+Winner: **Variant B** (+0.17 over baseline)
+
+Recommendation: adopt Variant B via `/ciel-improve`
+
+Result persisted: evals/results/flux-narrator-2026-04-17-142345.json
+```
+
+---
+
+## Guardrails
+
+- **Max 20 eval entries per dataset** — prevents runaway costs
+- **Max 3 variants per skill** — A/B/C, more is noise
+- **Cost estimation** — displayed before starting; user can abort if > 500k tokens projected
+- **Read-only evals** — `--disallowed-tools "Write Edit NotebookEdit"` to prevent side effects
+- **Graceful fallback** — if `claude --print` is unavailable, outputs manual eval prompts and waits for user input
+
+---
+
+## When to run
+
+- Before and after every `/ciel-improve` pass (baseline vs improved)
+- On every CHANGELOG version bump — regression sanity check
+- When creating a new skill — establish baseline score
+- When adding new eval criteria — re-score existing skills
+
+---
+
+## Eval dataset format
+
+One JSON object per line (JSONL). See `evals/datasets/depth-classification.jsonl` for examples. Required fields:
+
+- `id` — unique in dataset
+- `input` — prompt / context passed to skill
+- `expected_behavior` — object mapping criterion name → boolean
+- `skill` — which skill this tests
+
+See `skills/meta/skill-variant-evaluator/reference.md` for the full schema and supported criterion evaluators.

package/assets/platforms/opencode/.opencode/commands/ciel-improve.md

@@ -1,19 +1,13 @@
 ---
-command: ciel-improve
-description: Self-improvement — analyze sessions and propose skill patches
-agent: ciel-improver
-subtask: true
+description: Slash trigger for the ciel-improve skill on OpenCode.
 ---
 
-# /ciel-improve — Self-improvement
+Invoke the `ciel-improve` skill via the Skill tool with the user's arguments:
 
-Analyzes recent session transcripts to detect repeated failure modes, user corrections, and skill output truncation, then produces a patch-set proposing specific rewrites for Ciel skills.
+```
+$ARGUMENTS
+```
 
-Usage: `/ciel-improve`
+If `$ARGUMENTS` is empty, invoke the skill with no argument — it will classify the current context and prompt for a task if needed.
 
-## Process
-
-1. Scans `.ciel/learnings.md` for recent user corrections
-2. Analyzes session transcripts for failure patterns
-3. Produces a patch-set with specific skill rewrites
-4. Never rewrites autonomously — returns proposals for review
+The full logic (depth classifier, intent routing, pipeline selection, agent dispatch rules) lives in the `ciel-improve` skill itself. This command file is a thin trigger; modify the skill, not this file, to change behavior.