@neikyun/ciel 6.14.0 → 6.14.2

package/assets/.claude/hooks/check-dispatch-gate.sh

@@ -1,12 +1,8 @@
 #!/bin/bash
-# Ciel — PreToolUse hook for Read|Bash
-# Trigger: PreToolUse on Read|Bash
-# Purpose: BLOCK inline source-code research until ciel-researcher is dispatched.
-#   Forces the model to dispatch researcher + explorer in parallel before
-#   reading source files or running research commands (grep, cat, curl, rg, etc.).
-# Always allows: config files, project docs, CI files, state files.
-# Escape hatch: [CIEL_GATE_BYPASS] anywhere in the tool input bypasses the gate.
-# Dispatch tracker: /tmp/ciel_dispatched.* (created by SubagentStart hooks)
+# Ciel v9 — PreToolUse hook for Read|Bash
+# Gate DISPATCH: blocks source-code Read/Bash until researcher+explorer dispatched.
+# Always allows: config files, docs, CI files, .ciel/*, .claude/*
+# Escape hatch: [CIEL_GATE_BYPASS] in tool input
 
 INPUT=$(cat 2>/dev/null || echo "{}")
 
@@ -16,26 +12,21 @@ TASK_DEPTH="Standard"
 if [ -n "$PROJECT_DIR" ] && [ -f "$PROJECT_DIR/.ciel/last-depth" ]; then
   TASK_DEPTH=$(cat "$PROJECT_DIR/.ciel/last-depth" 2>/dev/null || echo "Standard")
 fi
-
-# Trivial + Spike tasks always pass — no dispatch required
 [ "$TASK_DEPTH" = "Trivial" ] && exit 0
 [ "$TASK_DEPTH" = "Spike" ] && exit 0
 
 # ── Bypass check ──
 if echo "$INPUT" | grep -q '\[CIEL_GATE_BYPASS\]'; then
-  echo "[CIEL] Dispatch gate bypassed via [CIEL_GATE_BYPASS]" >&2
+  echo "[CIEL] Dispatch gate bypassed" >&2
   exit 0
 fi
 
 # ── Dispatch check ──
-# If any Ciel agent has been dispatched this session, allow inline research.
-# /tmp/ciel_dispatched.* files are created by SubagentStart hooks for
-# ciel-researcher, ciel-explorer, and ciel-critic.
 if ls /tmp/ciel_dispatched.* >/dev/null 2>&1; then
   exit 0
 fi
 
-# ── Extract target ──
+# ── Extract tool fields ──
 TOOL_NAME=$(echo "$INPUT" | python3 -c "
 import sys, json
 try:
@@ -65,11 +56,9 @@ except:
     print('')
 " 2>/dev/null || echo "")
 
-# ── Read gate ──
-# Always-allow list: config files the model MUST be able to read for DOCS step.
-# These are needed BEFORE any dispatch — CLAUDE.md, AGENTS.md, .ciel/*, .claude/*,
-# SKILL.md, package.json, README, Makefile, VERSION, docker-compose, CI configs.
+# ── Read gate: allow config/docs, block source code ──
 if [ "$TOOL_NAME" = "Read" ] && [ -n "$FILE_PATH" ]; then
+  # Always-allow: .ciel, .claude, .github, project config, docs
   if echo "$FILE_PATH" | grep -qE '(^|/)\.(ciel|claude|github|opencode)(/|$|\.)'; then
     exit 0
   fi
@@ -80,41 +69,25 @@ if [ "$TOOL_NAME" = "Read" ] && [ -n "$FILE_PATH" ]; then
     exit 0
   fi
   if echo "$FILE_PATH" | grep -qE '\.(yml|yaml|toml|cfg|ini|conf|json|md|txt|css|html|xml|svg)$'; then
-    # Config/docs files — allow (but NOT source code like .ts in JSON disguise)
-    # The depth classification + pipeline docs phase needs broad config access
     exit 0
   fi
 
-  # Source code file — BLOCK until researcher dispatched
-  echo "[CIEL DISPATCH GATE] BLOCKED: Read $(basename "$FILE_PATH") before researcher dispatch" >&2
-  echo "" >&2
-  echo "  Depth: $TASK_DEPTH — no Ciel agent dispatched yet." >&2
-  echo "  Ciel pipeline requires dispatching ciel-researcher + ciel-explorer" >&2
-  echo "  in parallel BEFORE reading source code. This ensures official docs," >&2
-  echo "  anti-patterns, and codebase patterns are checked first." >&2
-  echo "" >&2
-  echo "  To proceed without dispatch: add [CIEL_GATE_BYPASS] to the tool input." >&2
-  echo "  But prefer dispatching — it prevents the blind-pattern-copy anti-pattern." >&2
+  echo "[CIEL DISPATCH GATE] Blocked: Read $(basename "$FILE_PATH") before researcher dispatch" >&2
+  echo "  Dispatch ciel-researcher + ciel-explorer in parallel first." >&2
+  echo "  Or add [CIEL_GATE_BYPASS] to bypass." >&2
   exit 2
 fi
 
-# ── Bash gate ──
-# Allow infrastructure commands (ls, find, git status, mkdir, cd, npm, node -v, etc.)
-# Block research commands that read/search source files without dispatch.
+# ── Bash gate: allow infra, block source-code research ──
 if [ "$TOOL_NAME" = "Bash" ] && [ -n "$BASH_CMD" ]; then
-  # Always-allow patterns: infrastructure, package management, git meta
   if echo "$BASH_CMD" | grep -qE '^(ls |find |git (status|diff|log|branch|remote|config|stash|add |commit|push|pull|fetch|checkout|switch|restore)|mkdir |cd |npm |npx |node -[vp]|pnpm |yarn |cargo |pip |poetry |python3 -c|which |type |command -v|echo |cat .*(\.json|\.md|\.yml|\.yaml|\.toml|\.lock|VERSION|Makefile|README|\.gitignore)|gh (pr|issue|release|run|repo|workflow))'; then
     exit 0
   fi
 
-  # Research commands that scan/read source code — BLOCK
   if echo "$BASH_CMD" | grep -qE '(grep |rg |ag |cat .*\.(kt|ts|tsx|js|jsx|py|go|rs|rb|java|php|scala|swift|cs|cpp|c|h|vue|svelte)|tail |head |curl |wget )'; then
-    echo "[CIEL DISPATCH GATE] BLOCKED: Research Bash before researcher dispatch" >&2
-    echo "" >&2
-    echo "  Depth: $TASK_DEPTH — no Ciel agent dispatched yet." >&2
+    echo "[CIEL DISPATCH GATE] Blocked: research Bash before dispatch" >&2
     echo "  Command: $(echo "$BASH_CMD" | cut -c1-80)" >&2
-    echo "  Dispatch ciel-researcher + ciel-explorer first." >&2
-    echo "  Or add [CIEL_GATE_BYPASS] if this is infrastructure." >&2
+    echo "  Dispatch ciel-researcher + ciel-explorer first, or use [CIEL_GATE_BYPASS]." >&2
     exit 2
   fi
 fi

package/assets/.claude/hooks/memory-engine.py

@@ -26,6 +26,18 @@ import secrets
 from datetime import datetime, timezone
 from pathlib import Path
 
+# ─── Structured Logging ──────────────────────────────────────────────────────
+
+def _log(level, message, **context):
+    """Write structured JSON log line to stderr. Never touches stdout."""
+    entry = {
+        "ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+        "level": level,
+        "msg": message,
+        **context,
+    }
+    print(json.dumps(entry, ensure_ascii=False), file=sys.stderr)
+
 # ─── Constants ──────────────────────────────────────────────────────────────
 
 TOKEN_CAPS = {
@@ -494,6 +506,7 @@ def cmd_query(args):
         for mid, m, _ in selected:
             m['trigger_count'] = (m.get('trigger_count') or 0) + 1
             m['last_triggered'] = iso_now
+            m['last_edited'] = iso_now
 
         for _, _, line in selected:
             output_lines.append(line)
@@ -534,7 +547,7 @@ def cmd_init(args):
 # Fields whose values must remain string regardless of how they look.
 # Prevents int-coercion of numeric-looking ids (e.g. "12345") which would
 # break the index keying and JSON round-trip.
-_STRING_FIELDS = frozenset({'id', 'title', 'last_triggered', 'captured_at', 'file', 'source', 'captured_from'})
+_STRING_FIELDS = frozenset({'id', 'title', 'last_triggered', 'captured_at', 'last_edited', 'file', 'source', 'captured_from'})
 
 
 def parse_yaml_frontmatter(text: str) -> dict:
@@ -567,7 +580,13 @@ def parse_yaml_frontmatter(text: str) -> dict:
                 out[key] = []
             elif val.startswith('[') and val.endswith(']'):
                 inner = val[1:-1].strip()
-                items = [x.strip().strip('"\'') for x in inner.split(',') if x.strip()]
+                items = []
+                seen = set()
+                for x in inner.split(','):
+                    x = x.strip().strip('"\'')
+                    if x and x not in seen:
+                        seen.add(x)
+                        items.append(x)
                 out[key] = items
             elif val.lower() == 'null' or val == '~':
                 out[key] = None
@@ -591,7 +610,7 @@ def cmd_rebuild_index(args):
     cwd = resolve_cwd(args.cwd)
     base = cwd / '.ciel' / 'memory'
     if not base.exists():
-        print(f"No memory directory at {base}", file=sys.stderr)
+        _log("error", "No memory directory", path=str(base))
         sys.exit(1)
 
     # Preserve trigger counts from existing index. cmd_query updates counts
@@ -607,6 +626,29 @@ def cmd_rebuild_index(args):
         except (json.JSONDecodeError, OSError):
             pass
 
+    # Index schema contract (version 2)
+    # ─────────────────────────────────────────────────────────────────
+    # memories:     mid → frontmatter          1:1  PK — mid is unique
+    # by_path:      pattern → [mid, ...]       1:N  FK → memories
+    # by_symbol:    symbol  → [mid, ...]       1:N  FK → memories
+    # by_intent:    intent  → [mid, ...]       1:N  FK → memories
+    # by_language:  lang    → [mid, ...]       1:N  FK → memories
+    #
+    # Guarantees (enforced at rebuild time):
+    #   G1 — Referential integrity: every mid in any index exists in memories
+    #   G2 — No self-duplicates: a given (key, mid) pair appears at most once
+    #        per index list (setdefault+append is safe when source frontmatter
+    #        has no duplicate entries — which the parser guarantees)
+    #   G3 — Index values are always lists, never None/scalar
+    #   G4 — No orphan index keys: empty [] keys are pruned after build
+    #
+    # Non-guarantees (by design):
+    #   - Order within index lists is insertion order (filesystem order), not
+    #     relevance-sorted. Callers (cmd_query) re-rank by trigger_count.
+    #   - Duplicate mids across different keys in the same index: a memory
+    #     with symbols [auth, oauth] appears under both keys. This is correct.
+    #   - Index is a cache: rebuild-index reconstructs it from source .md files.
+    #     The source of truth is always the .md frontmatter, never the index.
     idx = {
         "version": 2,
         "memories": {},
@@ -638,6 +680,10 @@ def cmd_rebuild_index(args):
                 old_lt = old.get('last_triggered')
                 if old_lt and not fm.get('last_triggered'):
                     fm['last_triggered'] = old_lt
+                old_le = old.get('last_edited')
+                new_le = fm.get('last_edited')
+                if old_le and (not new_le or old_le > new_le):
+                    fm['last_edited'] = old_le
             fm['file'] = str(mdfile.relative_to(base))
             idx['memories'][mid] = fm
             for path in fm.get('path_patterns') or []:
@@ -650,7 +696,21 @@ def cmd_rebuild_index(args):
                 idx['by_language'].setdefault(lang, []).append(mid)
             parsed += 1
         except (OSError, UnicodeDecodeError) as e:
-            print(f"Warning: skipping {mdfile}: {e}", file=sys.stderr)
+            _log("warn", "Skipping unparseable memory file", file=str(mdfile), error=str(e))
+
+    # Integrity checks (G1, G3)
+    mid_set = set(idx['memories'].keys())
+    for index_name in ('by_path', 'by_symbol', 'by_intent', 'by_language'):
+        idx_map = idx[index_name]
+        empty_keys = [k for k, v in idx_map.items() if not v]
+        for k in empty_keys:
+            del idx_map[k]
+        for key, mids in idx_map.items():
+            orphans = [m for m in mids if m not in mid_set]
+            if orphans:
+                _log("warn", "Dangling reference in index — repaired",
+                     index=index_name, key=key, orphans=orphans)
+                idx_map[key] = [m for m in mids if m in mid_set]
 
     out = base / 'index.json'
     atomic_write_json(out, idx)
@@ -705,6 +765,7 @@ def cmd_capture(args):
         "captured_at": iso_now,
         "captured_from": args.captured_from or 'runtime',
         "source": args.source or 'manual capture',
+        "last_edited": iso_now,
         "trigger_count": 0,
         "last_triggered": None,
         "stale_after_days": 90,
@@ -759,7 +820,7 @@ def cmd_analyze(args):
     cwd = resolve_cwd(args.cwd)
     base = cwd / '.ciel' / 'memory'
     if not base.exists():
-        print(f"No memory directory at {base}", file=sys.stderr)
+        _log("error", "No memory directory", path=str(base))
         sys.exit(1)
 
     index_file = base / 'index.json'

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

@@ -1,10 +1,7 @@
 #!/bin/bash
-# Ciel — PreToolUse hook for Write/Edit
-# Trigger: PreToolUse on Write|Edit
-# Purpose: BLOCK source code writes until dispatch gate passes (v8 — enforcement)
-# Test files and non-code files pass through (always allowed).
-# Escape hatch: [CIEL_GATE_BYPASS] anywhere in the tool input bypasses the gate.
-# Dispatch tracker: /tmp/ciel_dispatched.* (created by SubagentStart hooks)
+# Ciel v9 — PreToolUse hook for Write/Edit
+# Gate DISPATCH: blocks source code writes until researcher+explorer dispatched
+# Escape hatch: [CIEL_GATE_BYPASS] in tool input bypasses the gate
 
 INPUT=$(cat 2>/dev/null || echo "{}")
 
@@ -22,87 +19,55 @@ except:
 
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-}"
 
-# === BYPASS CHECK ===
-# [CIEL_GATE_BYPASS] anywhere in the input is an intentional override
+# ── Bypass check ──────────────────────────────────────────────────────────
 if echo "$INPUT" | grep -q '\[CIEL_GATE_BYPASS\]'; then
-  echo "[CIEL] Gate bypassed via [CIEL_GATE_BYPASS] — allowing write to $(basename "$FILE_PATH")" >&2
+  echo "[CIEL] Gate bypassed — allowing write to $(basename "$FILE_PATH")" >&2
   exit 0
 fi
 
-# === FILE CLASSIFICATION ===
-# Source code files that require dispatch before editing
+# ── File classification ───────────────────────────────────────────────────
 IS_SOURCE=0
 if echo "$FILE_PATH" | grep -qE '\.(kt|java|ts|tsx|js|jsx|py|go|rs|rb|php|cs|cpp|c|swift|scala|vue|svelte)$'; then
   IS_SOURCE=1
 fi
 
-# Test files always pass (test-first RED)
 IS_TEST=0
 if echo "$FILE_PATH" | grep -qE '\.(test|spec)\.|_test\.|_spec\.|/test/|/tests/|/__tests__/'; then
   IS_TEST=1
 fi
 
-# === DISPATCH GATE CHECK ===
-# /tmp/ciel_dispatched.* files created by SubagentStart hooks when Ciel agents dispatch
+# ── Dispatch gate — the core enforcement ──────────────────────────────────
 DISPATCHED=0
 if ls /tmp/ciel_dispatched.* >/dev/null 2>&1; then
   DISPATCHED=1
 fi
 
-# === DEPTH CHECK ===
-# Read depth classification from UserPromptSubmit hook (auto-bypass for Trivial)
 TASK_DEPTH="Standard"
 if [ -n "$PROJECT_DIR" ] && [ -f "$PROJECT_DIR/.ciel/last-depth" ]; then
   TASK_DEPTH=$(cat "$PROJECT_DIR/.ciel/last-depth" 2>/dev/null || echo "Standard")
 fi
 
-# === DISPATCH GATE — BLOCK (v8 enforcement) ===
-# Block source code edits when no Ciel agent has been dispatched.
-# Auto-bypass for Trivial tasks (depth classified by UserPromptSubmit hook).
-# Skip non-code files (docs, config, JSON, YAML, etc.) — safe to edit inline.
-# Skip test files — test-first RED means tests must be written before source.
 if [ "$IS_SOURCE" -eq 1 ] && [ "$IS_TEST" -eq 0 ] && [ "$DISPATCHED" -eq 0 ] && [ "$TASK_DEPTH" != "Trivial" ]; then
-  echo "[CIEL DISPATCH GATE] BLOCKED: Write to $(basename "$FILE_PATH")" >&2
-  echo "" >&2
-  echo "  Depth: $TASK_DEPTH — no Ciel agent dispatched yet." >&2
-  echo "  Dispatch ciel-researcher + ciel-explorer in parallel (Agent tool)," >&2
-  echo "  with relevant domain skill names in the dispatch prompt." >&2
-  echo "" >&2
-  echo "  This is actually a Trivial task? Use [CIEL_GATE_BYPASS]." >&2
+  echo "[CIEL DISPATCH GATE] Write blocked: $(basename "$FILE_PATH") — no researcher+explorer dispatched yet." >&2
+  echo "  Dispatch them in parallel via Agent tool, then retry." >&2
+  echo "  Trivial task? Use [CIEL_GATE_BYPASS] in tool input." >&2
   exit 2
 fi
 
-# === FILE TRACK COUNT (RELIRE GATE) ===
+# ── RELIRE gate reminder (soft, after 3+ edits in session) ────────────────
 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']))))
+  COUNT=$(python3 -c "
+import json
+try:
+    with open('$PROJECT_DIR/.ciel/tracked-files.json') as f:
+        print(len(json.load(f)))
 except: print(0)
 " 2>/dev/null || echo "0")
 fi
 
-# RELIRE gate warning (3+ files → critic required)
 if [ "${COUNT:-0}" -ge 2 ] 2>/dev/null; then
-  echo "[CIEL RELIRE GATE] ${COUNT} file(s) edited — dispatch ciel-critic MODE=RELIRE when done." >&2
-fi
-
-# === FAIRE GATE REMINDER ===
-# Skip non-code files for faire gate
-if [ "$IS_SOURCE" -eq 0 ] && [ "$IS_TEST" -eq 0 ]; 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). After FAIRE: TESTER (run test suite)." >&2
-else
-  echo "  [CIEL] Standard path: invoke faire-gatekeeper (alternatives, idiomatic, quality, removal, test-first). After FAIRE: TESTER (run test suite)." >&2
+  echo "[CIEL REVIEW GATE] ${COUNT} files edited — dispatch ciel-critic MODE=RELIRE before commit." >&2
 fi
 
 exit 0

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

@@ -1,15 +1,13 @@
 #!/bin/bash
-# Ciel — SessionStart hook
-# Trigger: session begins or resumes
-# Purpose: print Ciel banner, load overlay context, set TRACE_ID for eval logging
+# Ciel v9 — SessionStart hook
+# Prints version banner + loads overlay context.
 # 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
+# Detect overlay
 OVERLAY=""
 for candidate in "$CWD/ciel-overlay.md" "$CWD/.claude/ciel-overlay.md"; do
   if [[ -f "$candidate" ]]; then
@@ -18,159 +16,48 @@ for candidate in "$CWD/ciel-overlay.md" "$CWD/.claude/ciel-overlay.md"; do
   fi
 done
 
-# ─── META-pending check ──────────────────────────────────────────────────
-# If previous session ended without META reflection after 3+ edits,
-# inject a prominent warning BEFORE resetting the tracker.
-META_PENDING=""
-if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -f "$CLAUDE_PROJECT_DIR/.ciel/meta-pending" ]; then
-  META_INFO=$(python3 -c "
-import json
-try:
-    with open('$CLAUDE_PROJECT_DIR/.ciel/meta-pending') as f:
-        d = json.load(f)
-    print(f\"{d.get('edits', '?')} files edited, pending since {d.get('since', '?')}\")
-except: print('unknown')
-" 2>/dev/null || echo "unknown")
-  META_PENDING="
-
-═══════════════════════════════════════════════════════════════
-[CIEL] META STILL DUE — Previous task ended without META reflection.
-  $META_INFO
-  Invoke Skill(meta-critiquer) to complete the 10-item reflection.
-  Clear .ciel/meta-pending when done.
-  DO NOT start a new task until META is complete.
-═══════════════════════════════════════════════════════════════
-"
-fi
-
-# 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)
+# Generate TRACE_ID
 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 version — project sentinel > user sentinel > npm package > VERSION file
 _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)
-        ;;
+      *.json) 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 "$META_PENDING" ]]; then
-  MSG+="$META_PENDING"
-fi
-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 ''
-        promo = [(mid, m) for mid, m in mems.items() if (m.get('trigger_count') or 0) >= 5 and str(m.get('file', '')).startswith('episodes/')]
-        promo_hint = ''
-        if promo:
-            promo.sort(key=lambda x: -(x[1].get('trigger_count') or 0))
-            promo_names = ', '.join([m.get('title', '?') for _, m in promo[:3]])
-            more_promo = f' +{len(promo) - 3} more' if len(promo) > 3 else ''
-            promo_hint = '\\nConsolidation candidates (' + str(len(promo)) + ' episodes >=5 triggers): ' + promo_names + more_promo + '. Run memoire-consolidator.'
-        print(f'Cued-recall memory active ({total} memories{more}):\\n' + '\\n'.join(lines) + promo_hint)
-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.)."
+MSG="Ciel v${CIEL_VERSION} — Trace: ${TRACE_ID}."
+if [[ -n "$OVERLAY" ]]; then
+  MSG+=" Overlay: $OVERLAY."
 fi
 
-# ─── Pre-flight checklist — injected into every session ──────────────────────
-MSG+=$'\n'"---"
-MSG+=$'\n'"Checklist pre-vol (verifier avant chaque tache) :"
-MSG+=$'\n'"  Logs : structured JSON + correlation ID par requete ?"
-MSG+=$'\n'"  Backups : RPO/RTO definis ? Test de restore fait ?"
-MSG+=$'\n'"  Cache : TTL + strategie d'invalidation en place ?"
-MSG+=$'\n'"  Timeouts : explicites (connect/read/request) — pas d'infini ?"
-MSG+=$'\n'"  Securite : auth, injection, CSRF, rate limiting verifies ?"
-MSG+=$'\n'"  Metriques : RED (Rate, Errors, Duration) exposees par endpoint ?"
-MSG+=$'\n'"  Deploiement : CI/CD automatise, health check, rollback possible ?"
-MSG+=$'\n'"  Pagination : cursor-based, limite max definie ?"
-MSG+=$'\n'"  Erreurs : structurees (code + message + details) ?"
-MSG+=$'\n'"  Angles morts : 3 choses identifiees qui manquent dans la demande ?"
-
 # ─── 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 [[ ! -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:]')
+    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."
+      MSG+=" [UPDATE] v${LOCAL_VER}→v${REMOTE_VER}. Run /ciel-update."
     fi
     mkdir -p "$HOME/.ciel" 2>/dev/null || true
     touch "$LAST_CHECK" 2>/dev/null || true