@neikyun/ciel 6.8.0 → 6.9.1

package/assets/.claude/hooks/pre-agent-gate.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Ciel — PreToolUse hook for Agent (subagent type gate)
+# Trigger: PreToolUse on Agent
+# Purpose: block Agent dispatches that don't use a ciel-* subagent_type.
+#   Generic agents bypass Haiku model, call caps, and researcher waterfall
+#   → cost 20K-160K tokens vs ~5K for a constrained Ciel agent.
+#
+# Escape hatch: include [CIEL_GATE_BYPASS] anywhere in the prompt to allow
+#   a non-ciel agent through (e.g. legitimate one-off native dispatch).
+
+set -euo pipefail
+
+input_json=""
+if [ ! -t 0 ]; then
+    input_json=$(cat)
+fi
+[ -z "$input_json" ] && exit 0
+
+parsed=$(echo "$input_json" | python3 -c "
+import json, sys
+try:
+    d = json.load(sys.stdin)
+    tool_input = d.get('tool_input', {})
+    subagent_type = tool_input.get('subagent_type', '')
+    prompt = tool_input.get('prompt', '')
+    print(subagent_type + '\t' + prompt[:200])
+except Exception:
+    print('\t')
+" 2>/dev/null)
+
+subagent_type="${parsed%%$'\t'*}"
+prompt_head="${parsed#*$'\t'}"
+
+# Allow explicit bypass
+if echo "$prompt_head" | grep -q "\[CIEL_GATE_BYPASS\]"; then
+    exit 0
+fi
+
+# Allow ciel-* subagent types
+if [[ "$subagent_type" == ciel-* ]]; then
+    exit 0
+fi
+
+# Block everything else — generic or non-ciel subagent_type
+label="${subagent_type:-<missing>}"
+python3 -c "
+import json
+print(json.dumps({
+    'hookSpecificOutput': {
+        'hookEventName': 'PreToolUse',
+        'permissionDecision': 'deny',
+        'permissionDecisionReason': '[CIEL AGENT GATE] Blocked: subagent_type=\"${label}\" is not a Ciel agent. Re-dispatch with subagent_type=\"ciel-researcher\" | \"ciel-explorer\" | \"ciel-critic\" | \"ciel-improver\". Generic agents bypass Haiku model, call caps, and researcher waterfall early-exit. Add [CIEL_GATE_BYPASS] to prompt to force-allow a non-Ciel dispatch.'
+    }
+}))"
+exit 0

package/assets/.claude/hooks/pre-tool-write.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+# Ciel — PreToolUse hook for Write/Edit
+# Trigger: PreToolUse on Write|Edit
+# Purpose: inject faire-gatekeeper + dispatch gate + pipeline reminders before code write
+# Critical files get additional stride-analyzer hint
+# Always exits 0 (never blocks), outputs reminders via stderr (reliable channel)
+# Dispatch counter: /tmp/ciel_dispatched set by SubagentStart hooks (ciel-researcher/explorer)
+
+INPUT=$(cat)
+
+FILE_PATH=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    tip = d.get('tool_input', {})
+    print(tip.get('file_path', tip.get('path', '')))
+except:
+    print('')
+" 2>/dev/null || echo "")
+
+[ -z "$FILE_PATH" ] && exit 0
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-}"
+
+# === DISPATCH GATE CHECK ===
+# /tmp/ciel_dispatched is created by SubagentStart hooks when ciel-researcher/explorer dispatch
+DISPATCHED=0
+DISPATCH_FLAG="/tmp/ciel_dispatched"
+if [ -f "$DISPATCH_FLAG" ]; then
+  DISPATCHED=1
+fi
+
+# === FILE TRACK COUNT (RELIRE GATE) ===
+COUNT=0
+if [ -n "$PROJECT_DIR" ] && [ -f "$PROJECT_DIR/.ciel/tracked-files.json" ]; then
+  COUNT=$(CIEL_PATH="$PROJECT_DIR/.ciel/tracked-files.json" python3 -c "
+import json, os
+try: print(len(json.load(open(os.environ['CIEL_PATH']))))
+except: print(0)
+" 2>/dev/null || echo "0")
+fi
+
+# Build warnings
+WARNINGS=""
+
+# Dispatch gate warning (no dispatched agents on non-trivial write)
+if [ "$DISPATCHED" -eq 0 ] && [ "$COUNT" -ge 1 ]; then
+  WARNINGS="${WARNINGS}[DISPATCH GATE] WARNING: Writing file ${FILE_PATH} without prior Task() dispatch (ciel-researcher + ciel-explorer). Was this classified as Trivial? If Standard+, dispatch subagents BEFORE writing code."
+fi
+
+# RELIRE gate warning
+if [ "${COUNT:-0}" -ge 2 ] 2>/dev/null; then
+  PIPELINE_WARN=" | CIEL PIPELINE: ${COUNT} file(s) edited. Have researcher+explorer been dispatched? If 3+ files: ciel-critic MODE=RELIRE required before merge."
+  WARNINGS="${WARNINGS}${PIPELINE_WARN}"
+fi
+
+# If only dispatch gate fires, prefix to std err
+if [ -n "$WARNINGS" ]; then
+  echo "[CIEL PRE-WRITE]" >&2
+  echo "$WARNINGS" | while IFS= read -r line; do
+    echo "  $line" >&2
+  done
+fi
+
+# === FAIRE GATE REMINDER ===
+# Skip non-code files
+if ! echo "$FILE_PATH" | grep -qE '\.(kt|java|ts|tsx|js|jsx|py|go|rs|rb|php|cs|cpp|c|swift|scala|vue|svelte|sql|sh|json|yaml|yml|toml)$'; then
+  exit 0
+fi
+
+# Check if file is critical path
+CRITICAL=false
+if echo "$FILE_PATH" | grep -qiE '(auth|Auth|security|Security|Token|Session|Password|Secret)'; then
+  CRITICAL=true
+fi
+
+if $CRITICAL; then
+  echo "  [CIEL] Critical path: invoke faire-gatekeeper, stride-analyzer must have run, test-first (RED)." >&2
+else
+  echo "  [CIEL] Standard path: invoke faire-gatekeeper (alternatives, idiomatic, quality, removal, test-first)." >&2
+fi
+
+exit 0

package/assets/.claude/hooks/session-start.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+# Ciel — SessionStart hook
+# Trigger: session begins or resumes
+# Purpose: print Ciel banner, load overlay context, set TRACE_ID for eval logging
+# Never blocks (exit 0 always). Stdout is added to Claude's context.
+
+INPUT=$(cat 2>/dev/null || echo "{}")
+CWD=$(echo "$INPUT" | python3 -c "import sys, json; print(json.load(sys.stdin).get('cwd', ''))" 2>/dev/null || pwd)
+# python3 succeeds with an empty string when stdin JSON lacks a 'cwd' key — fall through to pwd.
+[ -z "$CWD" ] && CWD="$(pwd)"
+
+# Detect overlay presence
+OVERLAY=""
+for candidate in "$CWD/ciel-overlay.md" "$CWD/.claude/ciel-overlay.md"; do
+  if [[ -f "$candidate" ]]; then
+    OVERLAY="$candidate"
+    break
+  fi
+done
+
+# Reset session-scoped edit tracker so META/RELIRE gates don't bleed across sessions
+if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -f "$CLAUDE_PROJECT_DIR/.ciel/tracked-files.json" ]; then
+  echo "[]" > "$CLAUDE_PROJECT_DIR/.ciel/tracked-files.json" 2>/dev/null || true
+fi
+
+# Generate TRACE_ID for this session (used by eval logging)
+TRACE_ID=$(date -u +%Y%m%dT%H%M%SZ)-$$
+export CIEL_TRACE_ID="$TRACE_ID"
+
+# Resolve Ciel version at runtime (single source of truth, no hardcoded drift).
+# Fallback chain: project sentinel → user sentinel → npm package → marketplace plugin → repo VERSION → unknown.
+# Note: $HOME/.ciel/version is "last writer wins" across npm installs from different projects —
+# project sentinel ($CWD/.ciel/version) is authoritative when present.
+_resolve_ciel_version() {
+  local v=""
+  for f in \
+    "$CWD/.ciel/version" \
+    "$HOME/.ciel/version" \
+    "$HOME/.claude/plugins/ciel/package.json" \
+    "$HOME/.claude/plugins/ciel/.claude-plugin/plugin.json" \
+    "$(dirname "$0")/../../VERSION" \
+    "$(dirname "$0")/../VERSION"; do
+    # Skip entries that resolved against an empty $CWD/$HOME (e.g., "/.ciel/version").
+    case "$f" in /.ciel/*|/.claude/*) continue ;; esac
+    [ -r "$f" ] || continue
+    case "$f" in
+      *.json)
+        # Anchor to line-start whitespace so we only match top-level "version",
+        # not nested keys like "schema_version" or `"version"` deeper in the doc.
+        v=$(sed -n 's/^[[:space:]]*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$f" 2>/dev/null | head -1)
+        ;;
+      *)
+        v=$(tr -d '[:space:]' <"$f" 2>/dev/null)
+        ;;
+    esac
+    [ -n "$v" ] && { echo "$v"; return; }
+  done
+  echo "unknown"
+}
+CIEL_VERSION="$(_resolve_ciel_version)"
+MSG="CIEL v${CIEL_VERSION} — Skills-first deep-reasoning active. "
+if [[ -n "$OVERLAY" ]]; then
+  MSG+="Overlay loaded: $OVERLAY. "
+else
+  MSG+="No overlay found at $CWD/ciel-overlay.md — create one for project-specific rules. "
+fi
+MSG+="Trace ID: $TRACE_ID. Principle: Understand before generating. Verify before claiming done."
+
+# ─── Cued-recall: surface relevant memories ──────────────────────────────────
+# If a memory corpus exists, list active (non-stale) memories so the model
+# knows what cues are available. Full content read on-demand. See ADR-0001.
+MEMORY_INDEX="$CWD/.ciel/memory/index.json"
+if [[ -f "$MEMORY_INDEX" ]]; then
+  MEMORY_SUMMARY=$(MEMORY_INDEX="$MEMORY_INDEX" python3 -c "
+import json, os
+try:
+    with open(os.environ['MEMORY_INDEX']) as f:
+        idx = json.load(f)
+    mems = idx.get('memories', {})
+    active = [(mid, m) for mid, m in mems.items() if not m.get('stale')]
+    if not active:
+        print('')
+    else:
+        # Sort by trigger_count desc, then by last_triggered desc
+        active.sort(key=lambda x: (-(x[1].get('trigger_count') or 0), x[1].get('last_triggered') or ''), reverse=False)
+        active.sort(key=lambda x: -(x[1].get('trigger_count') or 0))
+        top = active[:10]
+        lines = [f\"  [{mid}, {m.get('trigger_count', 0)}x] {m.get('title', '?')}\" for mid, m in top]
+        total = len(active)
+        more = f' (+{total - len(top)} more)' if total > len(top) else ''
+        print(f'Cued-recall memory active ({total} memories{more}):\\n' + '\\n'.join(lines))
+except Exception:
+    print('')
+" 2>/dev/null || echo "")
+  if [[ -n "$MEMORY_SUMMARY" ]]; then
+    MSG+=$'\n'"$MEMORY_SUMMARY"
+    MSG+=$'\n'"Memories auto-inject when path/symbol/intent cues match. Read full content from .ciel/memory/{episodes,concepts,guards}/ when relevant."
+  fi
+elif [[ -d "$CWD/.ciel" ]] || [[ -f "$CWD/.claude/settings.json" ]] || [[ -f "$CWD/opencode.json" ]] || [[ -f "$CWD/ciel-overlay.md" ]]; then
+  # Only suggest bootstrap if Ciel is actually installed in this project (not
+  # any random repo with a CLAUDE.md). Markers checked: .ciel/ dir, .claude
+  # settings, opencode config, or an explicit Ciel overlay.
+  MSG+=$'\n'"No cued-recall memory yet. Run /ciel-memory-bootstrap to scan project for ingestable tribal docs (lessons.md, ciel-overlay.md, .claude/rules/, etc.)."
+fi
+
+# ─── Update check (throttled to once per 24h, never blocks) ──────────────────
+# Fetches GitHub VERSION non-blocking (max 2s). Any failure → silent skip.
+MANIFEST="$HOME/.ciel/manifest.json"
+LAST_CHECK="$HOME/.ciel/.last-update-check"
+if [[ -f "$MANIFEST" ]]; then
+  STALE=false
+  if [[ ! -f "$LAST_CHECK" ]]; then
+    STALE=true
+  elif find "$LAST_CHECK" -mmin +1440 2>/dev/null | grep -q .; then
+    STALE=true
+  fi
+  if $STALE; then
+    LOCAL_VER=$(grep -oE '"version":[[:space:]]*"[^"]+"' "$MANIFEST" 2>/dev/null \
+      | head -1 | sed 's/.*"\([^"]*\)".*/\1/')
+    REMOTE_VER=$(curl -fsSL --max-time 2 \
+      https://raw.githubusercontent.com/KaosKyun/Ciel/main/VERSION 2>/dev/null \
+      | tr -d '[:space:]')
+    if [[ -n "$LOCAL_VER" && -n "$REMOTE_VER" && "$LOCAL_VER" != "$REMOTE_VER" ]]; then
+      MSG+=" [UPDATE] Ciel v$LOCAL_VER → v$REMOTE_VER available. Run /ciel-update."
+    fi
+    mkdir -p "$HOME/.ciel" 2>/dev/null || true
+    touch "$LAST_CHECK" 2>/dev/null || true
+  fi
+fi
+
+echo "$MSG"
+exit 0

package/assets/.claude/hooks/session-version-check.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Ciel — Session-start version check
+# Outputs to stderr so the user sees the notification.
+# Non-blocking: silent on fetch failure (offline/proxy).
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "$0")/.." && pwd)}"
+LOCAL_VERSION=$(cat "$PROJECT_DIR/VERSION" 2>/dev/null || echo "0.0.0")
+
+REMOTE_VERSION=$(curl -fsSL --connect-timeout 3 "https://raw.githubusercontent.com/KaosKyun/Ciel/main/VERSION" 2>/dev/null || true)
+
+if [ -n "$REMOTE_VERSION" ] && [ "$REMOTE_VERSION" != "$LOCAL_VERSION" ]; then
+  echo "[CIEL] Update available: v${LOCAL_VERSION} → v${REMOTE_VERSION}. Run /ciel-update to upgrade." >&2
+fi

package/assets/.claude/hooks/user-prompt-submit.sh

@@ -0,0 +1,112 @@
+#!/bin/bash
+# Ciel — UserPromptSubmit hook
+# Trigger: user submits a prompt (before Claude processes)
+# Purpose: light depth pre-classification hint injected into context
+# Invokes: depth-classifier skill (lightweight mode)
+# Never blocks (exit 0 always)
+
+INPUT=$(cat 2>/dev/null || echo "{}")
+PROMPT=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    print(d.get('prompt', ''))
+except:
+    print('')
+" 2>/dev/null || echo "")
+
+[ -z "$PROMPT" ] && exit 0
+
+# Mechanical depth signals
+DEPTH="Standard"  # default
+REASON=""
+
+# Check for Critical signals
+if echo "$PROMPT" | grep -qiE '\b(auth|authenti|author|jwt|oauth|password|secret|token|session|payment|credit.card|migration.*schema|2fa|mfa|encryption|credential|cookie.*security)\b'; then
+  DEPTH="Critical"
+  REASON="auth/security/payment keyword detected"
+fi
+
+# Check for Trivial signals (only if not Critical)
+if [[ "$DEPTH" != "Critical" ]] && echo "$PROMPT" | grep -qiE '\b(rename|typo|copyright|comment|readme|1-line|one.line|fix.typo|spelling)\b'; then
+  DEPTH="Trivial"
+  REASON="rename/typo/docs keyword detected"
+fi
+
+DISPATCH_GATE=""
+if [[ "$DEPTH" == "Standard" || "$DEPTH" == "Critical" ]]; then
+  DISPATCH_GATE=" | DISPATCH GATE: dispatch ciel-researcher + ciel-explorer in parallel BEFORE first Bash/Read/Edit."
+fi
+
+META_GATE=""
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-}"
+if [ -n "$PROJECT_DIR" ] && [ -f "$PROJECT_DIR/.ciel/tracked-files.json" ]; then
+  EDIT_COUNT=$(CIEL_PATH="$PROJECT_DIR/.ciel/tracked-files.json" python3 -c "
+import json, os
+try: print(len(json.load(open(os.environ['CIEL_PATH']))))
+except: print(0)
+" 2>/dev/null || echo "0")
+  if [ "${EDIT_COUNT:-0}" -gt 0 ] 2>/dev/null; then
+    META_GATE=" | META GATE: ${EDIT_COUNT} file(s) edited this session — complete 10-item META if previous task ended at PROUVER."
+  fi
+fi
+
+# ─── Cued-recall: intervention pattern detection ─────────────────────────────
+# When the user message contains a clear correction/intervention pattern,
+# suggest capturing it as a memory. Patterns are intentionally narrow to keep
+# false-positive rate low — generic words like "wait" / "stop" / "actually"
+# are NOT triggers on their own; they must combine with a negation/correction
+# adjacent. Never auto-silent — the model surfaces a question to the user.
+# See ADR-0001 and skill `memoire`.
+INTERVENTION_GATE=""
+# POSIX-ERE only (no PCRE lookahead). Patterns are intentionally high-precision
+# to avoid false positives on generic words (wait/stop/actually). Each pattern
+# is a clear signal of correction or "you missed something".
+if echo "$PROMPT" | grep -qiE "(tu as oublié|t'as oublié|n'oublie pas (que|de)|non en fait|non,? en fait|attention que|rappelle-toi (que|de)|ici on (fait|utilise) plutôt|non on (fait|utilise) plutôt|en fait c'est pas|c'est pas comme ça|mauvaise approche|tu te trompes|you forgot (to|that)|don't forget (to|that)|that's not (right|correct|how)|that's wrong|no[,]? actually|actually,? no|wait[,—-] (no|don't|you forgot)|stop[,—-] (no|you forgot|don't))"; then
+  INTERVENTION_GATE=" | CAPTURE GATE: intervention pattern detected — propose AskUserQuestion to capture as memory under .ciel/memory/episodes/ (skill: memoire). Never silent-write."
+fi
+
+# ─── Cued-recall: query memory engine for matching memories ──────────────────
+# Calls hooks/memory-engine.py if installed and a memory corpus exists. The
+# engine handles cue extraction (paths, symbols, intents, language), scoring,
+# token cap, decay, and trigger updates. See docs/adrs/0001-cued-recall-memory.md.
+MEMORY_OUTPUT=""
+ENGINE_PATH=""
+# Resolution order: same dir as this script (most reliable, found via BASH_SOURCE)
+# → project-relative paths in priority order → $HOME fallbacks. Covers local-mode
+# install (top-level hooks/), curl-mode install (.claude/hooks/ or ~/.claude/plugins/ciel/),
+# and OpenCode plugin layout (~/.config/opencode/...).
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd 2>/dev/null || echo "")"
+for candidate in \
+    "$SCRIPT_DIR/memory-engine.py" \
+    "$PROJECT_DIR/.claude/hooks/memory-engine.py" \
+    "$PROJECT_DIR/hooks/memory-engine.py" \
+    "$HOME/.claude/plugins/ciel/memory-engine.py" \
+    "$HOME/.ciel/hooks/memory-engine.py"; do
+  if [[ -n "$candidate" ]] && [[ -f "$candidate" ]]; then
+    ENGINE_PATH="$candidate"
+    break
+  fi
+done
+
+if [[ -n "$ENGINE_PATH" ]] && [[ -n "$PROJECT_DIR" ]] && [[ -f "$PROJECT_DIR/.ciel/memory/index.json" ]]; then
+  DEPTH_LOWER=$(echo "$DEPTH" | tr '[:upper:]' '[:lower:]')
+  MEMORY_OUTPUT=$(python3 "$ENGINE_PATH" query --prompt "$PROMPT" --cwd "$PROJECT_DIR" --depth "$DEPTH_LOWER" 2>/dev/null || echo "")
+fi
+
+MSG_BASE="CIEL depth hint: $DEPTH ($REASON).$DISPATCH_GATE$META_GATE$INTERVENTION_GATE Invoke depth-classifier if ambiguous before routing pipeline."
+
+# Emit JSON via python to handle newlines and quoting safely
+MSG_BASE="$MSG_BASE" MEMORY_OUTPUT="$MEMORY_OUTPUT" python3 -c "
+import os, json
+base = os.environ.get('MSG_BASE', '')
+mem = os.environ.get('MEMORY_OUTPUT', '').strip()
+combined = base + ('\n\n' + mem if mem else '')
+print(json.dumps({
+    'hookSpecificOutput': {
+        'hookEventName': 'UserPromptSubmit',
+        'additionalContext': combined,
+    }
+}))
+"
+exit 0

package/assets/.claude/settings.json

@@ -20,7 +20,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "echo \"[CIEL v6] Session started — Pipeline: DOCS → QUOI → ASK → AVEC QUOI → DIVERGE → RECHERCHE → CODEBASE → EVALUER → ASK2 → FAIRE → RELIRE → PROUVER → MEMOIRE → META\" && \"$CLAUDE_PROJECT_DIR\"/hooks/session-version-check.sh"
+            "command": "echo \"[CIEL v6] Session started — Pipeline: DOCS → QUOI → ASK → AVEC QUOI → DIVERGE → RECHERCHE → CODEBASE → EVALUER → ASK2 → FAIRE → RELIRE → PROUVER → MEMOIRE → META\" && \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/session-version-check.sh"
           }
         ]
       }
@@ -35,7 +35,7 @@
           },
           {
             "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/hooks/pre-tool-write.sh"
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-tool-write.sh"
           }
         ]
       },
@@ -54,7 +54,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/hooks/pre-agent-gate.sh"
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-agent-gate.sh"
           }
         ]
       }
@@ -69,7 +69,7 @@
           },
           {
             "type": "command",
-            "command": "COUNT=$(cat \"$CLAUDE_PROJECT_DIR/.ciel/tracked-files.json\" 2>/dev/null | python3 -c \"import sys,json; d=json.load(sys.stdin); print(len(d))\" 2>/dev/null || echo \"?\"); echo \"[CIEL] Tracked files: $COUNT — RELIRE recommended at 5+ files or on Critical paths\" >&2"
+            "command": "COUNT=$(cat \"${CLAUDE_PROJECT_DIR:-$PWD}/.ciel/tracked-files.json\" 2>/dev/null | python3 -c \"import sys,json; d=json.load(sys.stdin); print(len(d))\" 2>/dev/null || echo \"?\"); echo \"[CIEL] Tracked files: $COUNT — RELIRE recommended at 5+ files or on Critical paths\" >&2"
           }
         ]
       }

package/assets/commands/ciel-audit.md

@@ -1,10 +1,10 @@
 ---
-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.
+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 < 90, creates a GitHub Issue on the Ciel repository with the findings and session timeline. Hook-independent — works even when Ciel hooks are broken.
 ---
 
 # /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.*
+*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 90, 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`
 
@@ -85,17 +85,79 @@ If npm version > local version, include an **Update notification** in the report
 
 #### Dimension 8: Platform health — penalty up to -5
 
-Check which Ciel platforms are present and whether they have valid configurations:
+Check that Ciel platform installations exist and are valid. Ciel currently supports two platforms: **claude** and **opencode**.
 
+**Claude Code** — check for expected agent and hook files:
 ```bash
-ls /path/to/platforms/ 2>/dev/null
+CLAUDE_AGENTS=$(ls .claude/agents/ciel-*.md 2>/dev/null | wc -l | tr -d ' ')
+CLAUDE_HOOK=$(test -f .claude/hooks/session-start.sh && echo "1" || echo "0")
+CLAUDE_SETTINGS=$(test -f .claude/settings.json && echo "1" || echo "0")
+echo "Claude: agents=$CLAUDE_AGENTS hook=$CLAUDE_HOOK settings=$CLAUDE_SETTINGS"
+if [ "$CLAUDE_AGENTS" -ge 3 ] && [ "$CLAUDE_HOOK" = "1" ] && [ "$CLAUDE_SETTINGS" = "1" ]; then
+  echo "Claude platform: OK"
+else
+  echo "Claude platform: INCOMPLETE"
+fi
 ```
+Expected: at least 3 agent files + session-start.sh + settings.json
 
-Expected platforms: codex, cursor, kilocode, lmstudio, ollama, opencode, windsurf
+**OpenCode** — check for expected plugin, agent, and command files:
+```bash
+# Plugin file may be ciel.ts (legacy) or ciel.js (v6+ runtime); accept either.
+OPENCODE_PLUGIN=$( ( test -f .opencode/plugins/ciel.ts || test -f .opencode/plugins/ciel.js ) && echo "1" || echo "0")
+OPENCODE_AGENTS=$(ls .opencode/agents/ciel-*.md 2>/dev/null | wc -l | tr -d ' ')
+OPENCODE_COMMANDS=$(ls .opencode/commands/ciel*.md 2>/dev/null | wc -l | tr -d ' ')
+echo "OpenCode: plugin=$OPENCODE_PLUGIN agents=$OPENCODE_AGENTS commands=$OPENCODE_COMMANDS"
+if [ "$OPENCODE_PLUGIN" = "1" ] && [ "$OPENCODE_AGENTS" -ge 3 ] && [ "$OPENCODE_COMMANDS" -ge 5 ]; then
+  echo "OpenCode platform: OK"
+else
+  echo "OpenCode platform: INCOMPLETE"
+fi
+```
+Expected: ciel plugin (ciel.ts or ciel.js) + at least 3 agent files + at least 5 command files
+
+Scoring:
+- Both platforms fully present and valid: **0**
+- One platform missing or incomplete: **-3**
+- Both platforms missing or critically incomplete: **-5**
+
+**Important**: Do NOT check for `.claude/plugins/ciel/platforms/` or `.opencode/platforms/` directories — these are not part of the v6 architecture. Platform files are installed directly into `.claude/` and `.opencode/` respectively. Do NOT check for codex, cursor, kilocode, lmstudio, ollama, or windsurf — these platforms are not yet implemented.
+
+#### Dimension 9: Memory health — penalty up to -10
 
-- All platforms present: **0**
-- Missing 1-2 platforms: **-3**
-- Missing 3+ platforms: **-5**
+Check the cued-recall memory system (see `docs/adrs/0001-cued-recall-memory.md`):
+
+- **index.json missing**: `.ciel/memory/index.json` does not exist. The memory system was never bootstrapped. **-10**
+- **index.json exists but episodes/ empty**: `.ciel/memory/episodes/` has no files. Bootstrap ran but no memories were ingested, or the directory structure is incomplete. **-5**
+- **Low trigger ratio**: Count memories with `trigger_count > 0` vs total. If < 30% of memories have ever been triggered, the cue-matching system may be misconfigured or the memories are not relevant to actual usage. **-3**
+- **Stale memories**: Any memory with `stale: true` or with `last_triggered` older than `stale_after_days` (default 90). Stale memories waste index space and should be cleaned up by `memory-engine.py rebuild-index`. **-2**
+
+Scoring:
+- index.json missing: **-10** (blocks all other checks)
+- index.json present but no episode files: **-5**
+- All checks pass: **0**
+
+Run these checks:
+```bash
+# Check index.json exists
+test -f .ciel/memory/index.json && echo "index: OK" || echo "index: MISSING"
+
+# Count episodes
+EPISODES=$(ls .ciel/memory/episodes/*.md 2>/dev/null | wc -l | tr -d ' ')
+echo "episodes: $EPISODES"
+
+# Count triggered vs total (requires python3)
+python3 -c "
+import json
+with open('.ciel/memory/index.json') as f:
+    idx = json.load(f)
+mems = idx.get('memories', {})
+total = len(mems)
+triggered = sum(1 for m in mems.values() if m.get('trigger_count', 0) > 0)
+stale = sum(1 for m in mems.values() if m.get('stale'))
+print(f'total: {total}, triggered: {triggered} ({0 if total==0 else triggered*100//total}%), stale: {stale}')
+" 2>/dev/null || echo "memory check failed (no python3?)"
+```
 
 ---
 
@@ -106,9 +168,7 @@ Expected platforms: codex, cursor, kilocode, lmstudio, ollama, opencode, windsur
 | 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 |
+| 0-89 | Needs improvement | **Yes** — creates issue with timeline |
 
 The score is calculated automatically from the detected violations.
 
@@ -124,7 +184,7 @@ Begin the output with the literal line `# Ciel Session Audit Report`. End with t
 **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)
+**Platforms**: claude ✓ opencode ✓ (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>
@@ -173,6 +233,7 @@ Begin the output with the literal line `# Ciel Session Audit Report`. End with t
 | D6 — Intent routing | -<N> |
 | D7 — npm version | -<N> |
 | D8 — Platform health | -<N> |
+| D9 — Memory health | -<N> |
 | **Total** | **-<N>** |
 | **Health Score** | **<N>/100** |
 
@@ -202,7 +263,7 @@ Output a single short section — **no issue is created** for PASS verdicts:
 **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 ✓
+**Platforms**: claude ✓ opencode ✓
 **Session summary**: <N> /ciel invocation(s), <N> tool calls, <N> Task() dispatches.
 **Verdict**: PASS
 
@@ -213,11 +274,11 @@ Output a single short section — **no issue is created** for PASS verdicts:
 
 ---
 
-### GitHub Issue creation (only if score < 75)
+### GitHub Issue creation (only if score < 90)
 
-If the Ciel Health Score is **below 75**, create a GitHub Issue with the report AND the session timeline.
+If the Ciel Health Score is **below 90**, 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.
+**Important**: Do NOT create an issue if score >= 90. Only create for scores < 90.
 
 1. **Check for duplicate issues first**:
    ```bash
@@ -299,6 +360,6 @@ If the Ciel Health Score is **below 75**, create a GitHub Issue with the report
 - 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 an issue if score >= 90. Only create for score < 90.
 - 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.