@neikyun/ciel 6.10.0 → 6.11.0

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

@@ -18,6 +18,7 @@ See docs/adrs/0001-cued-recall-memory.md for design rationale.
 import sys
 import os
 import json
+import math
 import re
 import fnmatch
 import argparse
@@ -233,8 +234,16 @@ def match_path_pattern(pattern: str, paths) -> bool:
     return False
 
 
-def score_memory(mem, paths, symbols, intents, langs) -> int:
-    """Score a memory's relevance. 0 = exclude. Positive = include, higher first."""
+def score_memory(mem, paths, symbols, intents, langs, prompt_lower="") -> int:
+    """Score a memory's relevance. 0 = exclude. Positive = include, higher first.
+
+    Symbol and intent matching are case-insensitive and fall back to a
+    word-boundary search against the raw prompt. This lets a memory tagged
+    `symbols: [OkHttp]` fire on a prompt that mentions "okhttp" in prose,
+    and lets free-form intent tags (e.g. `intents: [okhttp, diagnostics]`)
+    match without being members of the fixed INTENT_KEYWORDS vocabulary.
+    Word boundaries prevent "test" intent from firing on "contest".
+    """
     # Hard language gate: if memory is language-specific AND prompt has language
     # cues AND no overlap → exclude. Avoids Kotlin memories firing on TS edits.
     mem_langs = mem.get('languages') or []
@@ -245,11 +254,23 @@ def score_memory(mem, paths, symbols, intents, langs) -> int:
     for pattern in mem.get('path_patterns') or []:
         if match_path_pattern(pattern, paths):
             score += 10
+
+    # Case-insensitive comparison sets — built once per memory call.
+    symbols_lower = {s.lower() for s in symbols}
+    intents_lower = {i.lower() for i in intents}
+
     for sym in mem.get('symbols') or []:
-        if sym in symbols:
+        sym_lower = sym.lower()
+        if sym_lower in symbols_lower or (
+            prompt_lower and re.search(r'\b' + re.escape(sym_lower) + r'\b', prompt_lower)
+        ):
             score += 8
+
     for intent in mem.get('intents') or []:
-        if intent in intents:
+        intent_lower = intent.lower()
+        if intent_lower in intents_lower or (
+            prompt_lower and re.search(r'\b' + re.escape(intent_lower) + r'\b', prompt_lower)
+        ):
             score += 5
 
     # No cue match at all → don't include (cued recall, not free recall)
@@ -399,6 +420,7 @@ def cmd_query(args):
     symbols = extract_symbol_cues(prompt)
     intents = extract_intent_cues(prompt)
     langs = extract_language_cues(prompt)
+    prompt_lower = prompt.lower()
     now = datetime.now(timezone.utc)
     iso_now = now.isoformat().replace('+00:00', 'Z')
 
@@ -418,7 +440,7 @@ def cmd_query(args):
         for mid, m in mems.items():
             if m.get('stale'):
                 continue
-            s = score_memory(m, paths, symbols, intents, langs)
+            s = score_memory(m, paths, symbols, intents, langs, prompt_lower=prompt_lower)
             if s > 0:
                 scored.append((s, mid, m))
 
@@ -674,6 +696,232 @@ def cmd_capture(args):
     print(f"Index rebuilt with memory: {mid}")
 
 
+def cmd_analyze(args):
+    """Mine recurring patterns across the corpus and emit insights.
+
+    Read-only on memories. Computes promotion candidates, dead anchors,
+    intent/path clusters and 7 health metrics, then writes:
+      - .ciel/memory/insights.json (machine; consumed by ciel-audit Dim 10)
+      - .ciel/memory/INSIGHTS.md (human digest)
+
+    Min-support floor (3 memories) enforced by the engine — refuses to
+    surface a "cluster" the model could narrate from sparse evidence.
+    Generation cap is computed from optional `derived_from` chains so a
+    future synthesizer cannot recurse on its own outputs without it
+    showing up as a metric.
+    """
+    cwd = resolve_cwd(args.cwd)
+    base = cwd / '.ciel' / 'memory'
+    if not base.exists():
+        print(f"No memory directory at {base}", file=sys.stderr)
+        sys.exit(1)
+
+    index_file = base / 'index.json'
+    if index_file.exists():
+        with index_file.open('r', encoding='utf-8') as f:
+            index = json.load(f)
+    else:
+        index = {"version": 2, "memories": {}, "by_path": {}, "by_symbol": {},
+                 "by_intent": {}, "by_language": {}}
+
+    memories = index.get('memories', {}) or {}
+    by_intent = index.get('by_intent', {}) or {}
+    by_path = index.get('by_path', {}) or {}
+
+    MIN_PROMOTION = 5
+    MIN_SUPPORT = 3
+
+    episodes = {mid: m for mid, m in memories.items()
+                if str(m.get('file', '')).startswith('episodes/')}
+    concepts = {mid: m for mid, m in memories.items()
+                if str(m.get('file', '')).startswith('concepts/')}
+    guards = {mid: m for mid, m in memories.items()
+              if str(m.get('file', '')).startswith('guards/')}
+
+    promotion_candidates = [mid for mid, m in episodes.items()
+                            if (m.get('trigger_count') or 0) >= MIN_PROMOTION]
+    promotion_candidates.sort(key=lambda mid: -(episodes[mid].get('trigger_count') or 0))
+
+    dead_anchors = []
+    for mid, m in memories.items():
+        patterns = m.get('path_patterns') or []
+        if not patterns:
+            continue
+        alive = False
+        for pat in patterns:
+            try:
+                # Path.glob raises NotImplementedError on absolute patterns
+                # in Python 3.13+, so route absolute paths through Path.exists
+                # directly. Relative patterns keep the glob (** support).
+                if pat.startswith('/'):
+                    if Path(pat).exists():
+                        alive = True
+                        break
+                elif any(True for _ in cwd.glob(pat)):
+                    alive = True
+                    break
+            except (ValueError, OSError, NotImplementedError):
+                continue
+        if not alive:
+            dead_anchors.append(mid)
+    dead_anchors.sort()
+
+    intent_clusters = {k: sorted(v) for k, v in by_intent.items() if len(v) >= MIN_SUPPORT}
+    path_clusters = {k: sorted(v) for k, v in by_path.items() if len(v) >= MIN_SUPPORT}
+
+    now = datetime.now(timezone.utc)
+
+    def days_ago(iso_str):
+        if not iso_str:
+            return None
+        try:
+            dt = datetime.fromisoformat(str(iso_str).replace('Z', '+00:00'))
+            return (now - dt).days
+        except (ValueError, TypeError):
+            return None
+
+    total = len(memories)
+
+    recent = sum(1 for m in memories.values()
+                 if (days_ago(m.get('captured_at')) or 10**6) <= 30)
+    recency_30d_ratio = round(recent / total, 3) if total else 0.0
+
+    intent_counts = [len(ids) for ids in by_intent.values() if ids]
+    intent_diversity_entropy = 0.0
+    if intent_counts:
+        total_tags = sum(intent_counts)
+        for c in intent_counts:
+            p = c / total_tags
+            intent_diversity_entropy -= p * math.log2(p)
+        intent_diversity_entropy = round(intent_diversity_entropy, 3)
+
+    dead_anchor_ratio = round(len(dead_anchors) / total, 3) if total else 0.0
+
+    # Generation depth from optional `derived_from` chains. Cycle-guarded.
+    def gen_depth(mid, seen):
+        if mid in seen:
+            return 0
+        m = memories.get(mid, {})
+        parents = m.get('derived_from') or []
+        if not parents:
+            return 1
+        return 1 + max(gen_depth(p, seen | {mid}) for p in parents)
+
+    max_generation_depth = max((gen_depth(mid, set()) for mid in memories), default=0)
+
+    flat_intents = [i for m in memories.values() for i in (m.get('intents') or [])]
+    tag_specificity = round(len(set(flat_intents)) / len(flat_intents), 3) if flat_intents else 0.0
+
+    promotion_ratio = round(len(concepts) / len(episodes), 3) if episodes else 0.0
+
+    corrections = sum(1 for m in episodes.values()
+                      if m.get('captured_from') in ('user-intervention', 'intervention'))
+    capture_correction_ratio = round(corrections / len(episodes), 3) if episodes else 0.0
+
+    health = {
+        "recency_30d_ratio": recency_30d_ratio,
+        "intent_diversity_entropy": intent_diversity_entropy,
+        "dead_anchor_ratio": dead_anchor_ratio,
+        "max_generation_depth": max_generation_depth,
+        "tag_specificity": tag_specificity,
+        "promotion_ratio": promotion_ratio,
+        "capture_correction_ratio": capture_correction_ratio,
+    }
+
+    insights = {
+        "version": 1,
+        "generated_at": now.isoformat().replace('+00:00', 'Z'),
+        "corpus_size": {
+            "episodes": len(episodes),
+            "concepts": len(concepts),
+            "guards": len(guards),
+            "total": total,
+        },
+        "promotion_candidates": promotion_candidates,
+        "dead_anchors": dead_anchors,
+        "intent_clusters": intent_clusters,
+        "path_clusters": path_clusters,
+        "health": health,
+        "thresholds": {
+            "min_promotion_trigger_count": MIN_PROMOTION,
+            "min_support_episodes": MIN_SUPPORT,
+        },
+    }
+
+    insights_json = base / 'insights.json'
+    atomic_write_json(insights_json, insights)
+
+    lines = [
+        "# Memory insights",
+        "",
+        f"_Generated {insights['generated_at']} by `memory-engine.py analyze`. Read by `ciel-audit` Dim 10._",
+        "",
+        f"**Corpus**: {len(episodes)} episodes, {len(concepts)} concepts, {len(guards)} guards (total {total}).",
+        "",
+        "## Health metrics",
+        "",
+    ]
+    for key, val in health.items():
+        lines.append(f"- `{key}`: **{val}**")
+    lines.append("")
+
+    if promotion_candidates:
+        lines += [
+            "## Promotion candidates",
+            "",
+            f"Episodes triggered >= {MIN_PROMOTION} times. Promote via skill `memoire-consolidator`.",
+            "",
+        ]
+        for mid in promotion_candidates:
+            m = episodes[mid]
+            lines.append(f"- `{mid}` (trigger_count={m.get('trigger_count', 0)}) - {m.get('title', '?')}")
+        lines.append("")
+
+    if dead_anchors:
+        lines += [
+            "## Dead anchors",
+            "",
+            "Memories whose every `path_patterns` entry resolves to no file. Triage in `.ciel/memory/review-queue.md`.",
+            "",
+        ]
+        for mid in dead_anchors:
+            m = memories[mid]
+            patterns = ", ".join(m.get('path_patterns') or [])
+            lines.append(f"- `{mid}` - {m.get('title', '?')} (patterns: {patterns})")
+        lines.append("")
+
+    if intent_clusters:
+        lines += [
+            "## Intent clusters",
+            "",
+            f"Intents shared by >= {MIN_SUPPORT} memories - recurring topics.",
+            "",
+        ]
+        for intent, ids in sorted(intent_clusters.items(), key=lambda x: -len(x[1])):
+            lines.append(f"- `{intent}` ({len(ids)}): {', '.join(ids)}")
+        lines.append("")
+
+    if path_clusters:
+        lines += [
+            "## Path clusters",
+            "",
+            f"Paths referenced by >= {MIN_SUPPORT} memories - high-traffic surface.",
+            "",
+        ]
+        for path, ids in sorted(path_clusters.items(), key=lambda x: -len(x[1])):
+            lines.append(f"- `{path}` ({len(ids)}): {', '.join(ids)}")
+        lines.append("")
+
+    insights_md = base / 'INSIGHTS.md'
+    insights_md.write_text('\n'.join(lines), encoding='utf-8')
+
+    print(f"Insights written: {insights_json.relative_to(cwd)}, {insights_md.relative_to(cwd)}")
+    print(f"  promotion_candidates: {len(promotion_candidates)}")
+    print(f"  dead_anchors: {len(dead_anchors)}")
+    print(f"  intent_clusters: {len(intent_clusters)}")
+    print(f"  path_clusters: {len(path_clusters)}")
+
+
 # ─── CLI ────────────────────────────────────────────────────────────────────
 
 
@@ -710,6 +958,10 @@ def main():
     cp.add_argument('--cwd', default=None)
     cp.set_defaults(func=cmd_capture)
 
+    ap = sub.add_parser('analyze', help='Mine patterns + emit insights.json + INSIGHTS.md (read by ciel-audit Dim 10)')
+    ap.add_argument('--cwd', default=None)
+    ap.set_defaults(func=cmd_analyze)
+
     args = p.parse_args()
     args.func(args)
 

package/assets/commands/ciel-audit.md

@@ -182,6 +182,47 @@ else
 fi
 ```
 
+#### Dimension 10: Memory insight quality — penalty up to -10
+
+Auto-runs the memory pattern analyzer (`python3 .claude/hooks/memory-engine.py analyze`) before scoring. The analyzer is read-only on the corpus — it scans `index.json`, computes pattern clusters and 7 health metrics, and writes `.ciel/memory/insights.json` + `.ciel/memory/INSIGHTS.md`. This dimension scores the *output* of that analysis: untreated promotion candidates, dead anchors, and structural drift in the memory corpus.
+
+**Anti-double-counting with Dim 9.** Memories already counted as `stale` in Dim 9 must be excluded from the Dim 10 dead-anchor penalty: compute `dead_anchors_new = insights.dead_anchors - dim9_stale_ids` before scoring. A single rotted memory that is both stale (Dim 9) and a dead anchor (Dim 10) is one defect, not two — never charge -4 for what costs the user one consolidator pass.
+
+- **Engine failed to produce insights**: `python3 .claude/hooks/memory-engine.py analyze` exited non-zero, OR `.ciel/memory/insights.json` was not written. The pattern surface is invisible — Dim 10 cannot grade. **-2**
+- **Promotion candidates ignored**: `insights.json.promotion_candidates.length >= 3` AND `insights.json.health.promotion_ratio == 0` — the analyzer flagged hot episodes (>= 5 triggers) but the consolidator skill has never crystallized any of them into concepts. The corpus accumulates without distillation. **-3**
+- **Dead anchors not triaged**: `insights.json.dead_anchors.length > 0` AND `.ciel/memory/review-queue.md` is missing or empty. Memories point to files that no longer exist; cued recall keeps firing on broken anchors until the user reviews. **-2**
+- **Recursion drift starting**: `insights.json.health.max_generation_depth >= 3`. Synthesizer outputs are being re-derived from prior synthesizer outputs beyond depth 2, violating ADR-0001's "no self-feeding loops" principle. **-2**
+- **Tag explosion**: `insights.json.health.tag_specificity > 0.9` AND total memories >= 10. Almost every tag is bespoke — clustering is impossible, recall degrades to per-memory matching. **-1**
+
+Run these checks:
+```bash
+# Auto-run analyzer (read-only on memories; writes only insights artifacts)
+python3 .claude/hooks/memory-engine.py analyze 2>&1 || echo "analyze: FAILED"
+
+# Read insights.json and emit per-check diagnostics
+python3 -c "
+import json, os, sys
+try:
+    with open('.ciel/memory/insights.json') as f:
+        ins = json.load(f)
+except FileNotFoundError:
+    print('insights: MISSING (engine failed?)')
+    sys.exit(0)
+pc = ins.get('promotion_candidates', [])
+da = ins.get('dead_anchors', [])
+h = ins.get('health', {})
+print(f'promotion_candidates: {len(pc)} (promotion_ratio={h.get(\"promotion_ratio\", 0)})')
+print(f'dead_anchors: {len(da)}')
+print(f'max_generation_depth: {h.get(\"max_generation_depth\", 0)}')
+print(f'tag_specificity: {h.get(\"tag_specificity\", 0)}')
+print(f'corpus: {ins.get(\"corpus_size\", {})}')
+review = '.ciel/memory/review-queue.md'
+print(f'review-queue: {\"present\" if os.path.exists(review) else \"absent\"}')
+" 2>/dev/null || echo "memory insights check failed (no python3?)"
+```
+
+The analyzer is **idempotent**: every audit run regenerates `insights.json` from the live corpus, so this dimension cannot be gamed by stale artifacts. Patches the audit recommends in this dimension should target either (a) running the consolidator skill to drain the promotion queue, or (b) populating `.ciel/memory/review-queue.md` to clear dead anchors.
+
 ---
 
 ### Scoring
@@ -257,6 +298,7 @@ Begin the output with the literal line `# Ciel Session Audit Report`. End with t
 | D7 — npm version | -<N> |
 | D8 — Platform health | -<N> |
 | D9 — Memory health | -<N> |
+| D10 — Memory insight quality | -<N> |
 | **Total** | **-<N>** |
 | **Health Score** | **<N>/100** |
 

package/assets/commands/ciel-status.md

@@ -15,7 +15,7 @@ Usage: `/ciel-status [--check]`
 ```
 ## CIEL STATUS
 
-Version: v6.10.0
+Version: v6.11.0
 Platform: Claude Code
 Config: .claude/settings.json — OK (4 hooks registered)
 Skills directory: skills/ — 43 skills loaded

package/assets/skills/ciel/SKILL.md

@@ -44,7 +44,7 @@ Principe : **"Understand before generating. Verify before claiming done."**
 | 12 | ADR | Documenter decisions architecturales |
 | 13 | RELIRE | @ciel-critic MODE=RELIRE |
 | 14 | PROUVER | Preuve AVANT/APRES |
-| 15 | MEMOIRE | Sauver .ciel/map.json |
+| 15 | MEMOIRE | Cued-recall: hooks capture interventions to .ciel/memory/episodes/ + index.json (see skill `memoire`, ADR-0001). |
 | 16 | META | 30s reflexion |
 
 ## Depth et dispatch
@@ -98,5 +98,6 @@ Pour les prompts non-anglais (francais, etc.), appliquer le matching semantique
 ## References
 
 - **Depth signals** → load `depth-classifier`
+- **Memory (etape 15 MEMOIRE)** → load `memoire` (capture/recall) + `memoire-consolidator` (maintenance). Hooks `user-prompt-submit.sh` (capture trigger) + `session-start.sh` (recall injection). Engine `hooks/memory-engine.py`. Token budget by depth: Trivial 1K / Standard 3K / Critical 5K injected memory tokens. Design: `docs/adrs/0001-cued-recall-memory.md`.
 - **Utility skills** → load pr-opener, commit-writer, branch-setup, issue-creator, issue-closer
 - For full philosophy and guards, see `reference.md`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neikyun/ciel",
-  "version": "6.10.0",
+  "version": "6.11.0",
   "description": "Ciel — Deep-reasoning pipeline for LLM-assisted development. OpenCode plugin + multi-platform CLI (OpenCode, Claude Code, more).",
   "main": "./dist/plugin/index.js",
   "types": "./dist/plugin/index.d.ts",