@neikyun/ciel 6.10.1 → 6.11.1

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
@@ -695,6 +696,257 @@ 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)
+
+    # Cap human-readable INSIGHTS.md sections when the corpus is large.
+    # insights.json (machine consumer) keeps everything; INSIGHTS.md is read
+    # by humans + by ciel-audit narration so token cost matters at scale.
+    LARGE_CORPUS_THRESHOLD = 150
+    TOP_N = 10
+
+    def maybe_cap(items):
+        if total > LARGE_CORPUS_THRESHOLD and len(items) > TOP_N:
+            return items[:TOP_N], len(items) - TOP_N
+        return items, 0
+
+    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:
+        shown, omitted = maybe_cap(promotion_candidates)
+        lines += [
+            "## Promotion candidates",
+            "",
+            f"Episodes triggered >= {MIN_PROMOTION} times. Promote via skill `memoire-consolidator`.",
+            "",
+        ]
+        for mid in shown:
+            m = episodes[mid]
+            lines.append(f"- `{mid}` (trigger_count={m.get('trigger_count', 0)}) - {m.get('title', '?')}")
+        if omitted:
+            lines.append(f"- _+{omitted} more, see insights.json_")
+        lines.append("")
+
+    if dead_anchors:
+        shown, omitted = maybe_cap(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 shown:
+            m = memories[mid]
+            patterns = ", ".join(m.get('path_patterns') or [])
+            lines.append(f"- `{mid}` - {m.get('title', '?')} (patterns: {patterns})")
+        if omitted:
+            lines.append(f"- _+{omitted} more, see insights.json_")
+        lines.append("")
+
+    if intent_clusters:
+        ranked = sorted(intent_clusters.items(), key=lambda x: -len(x[1]))
+        shown, omitted = maybe_cap(ranked)
+        lines += [
+            "## Intent clusters",
+            "",
+            f"Intents shared by >= {MIN_SUPPORT} memories - recurring topics.",
+            "",
+        ]
+        for intent, ids in shown:
+            lines.append(f"- `{intent}` ({len(ids)}): {', '.join(ids)}")
+        if omitted:
+            lines.append(f"- _+{omitted} more, see insights.json_")
+        lines.append("")
+
+    if path_clusters:
+        ranked = sorted(path_clusters.items(), key=lambda x: -len(x[1]))
+        shown, omitted = maybe_cap(ranked)
+        lines += [
+            "## Path clusters",
+            "",
+            f"Paths referenced by >= {MIN_SUPPORT} memories - high-traffic surface.",
+            "",
+        ]
+        for path, ids in shown:
+            lines.append(f"- `{path}` ({len(ids)}): {', '.join(ids)}")
+        if omitted:
+            lines.append(f"- _+{omitted} more, see insights.json_")
+        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 ────────────────────────────────────────────────────────────────────
 
 
@@ -731,6 +983,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-create-skill.md

@@ -1,10 +1,10 @@
 ---
-description: 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 ≤1536, 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).*
+*Generates a valid SKILL.md scaffold following Anthropic Skills-first rules (kebab-case name ≤64 chars, YAML frontmatter ≤1536-char description, ≤500-line body, progressive disclosure to one reference.md).*
 
 Usage: `/ciel-create-skill <name> <purpose>`
 

package/assets/commands/ciel-status.md

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

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

@@ -265,7 +265,7 @@ Generates a valid SKILL.md scaffold following Ciel's conventions. Returns a diff
 - Third person: "Analyzes X" ✓ / "I analyze X" ✗
 - Front-load use case + trigger keywords
 - Include "Use when..." clause
-- ≤ 1024 chars, recommended 200-500
+- ≤ 1536 chars, recommended 200-500
 
 ### 3. Scaffold SKILL.md
 
@@ -333,7 +333,7 @@ Problems: no trigger, no output, no specificity.
 
 - [ ] Name valid kebab-case, ≤ 64 chars, unique?
 - [ ] Category is one of the 5 valid categories?
-- [ ] Description: third person, ≤ 1024 chars, includes trigger?
+- [ ] Description: third person, ≤ 1536 chars, includes trigger?
 - [ ] SKILL.md ≤ 300 lines?
 - [ ] No overlap with existing skills (grep checked)?
 - [ ] YAML frontmatter valid?

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

@@ -7,12 +7,12 @@ 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: 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 ≤1536, 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).*
+*Generates a valid SKILL.md scaffold following Anthropic Skills-first rules (kebab-case name ≤64 chars, YAML frontmatter ≤1536-char description, ≤500-line body, progressive disclosure to one reference.md).*
 
 Usage: `/ciel-create-skill <name> <purpose>`
 

package/assets/platforms/opencode/.opencode/commands/ciel-memory-bootstrap.md

@@ -0,0 +1,195 @@
+---
+description: Scan project for ingestable tribal docs (lessons.md, ciel-overlay.md, .claude/rules/, Claude Code auto-memory at ~/.claude/projects/<slug>/memory/, etc.) and propose ingestion into the cued-recall memory under .ciel/memory/. Reports findings if no sources found. Always confirms each candidate with the user before writing.
+---
+
+# /ciel-memory-bootstrap — Initialize Cued-Recall Memory
+
+**Purpose:** First-run scan of an existing project to convert tribal knowledge already documented in `lessons.md`, `ciel-overlay.md`, `.claude/rules/`, Claude Code's per-project auto-memory (`~/.claude/projects/<slug>/memory/`), and similar files into the structured cued-recall memory at `.ciel/memory/`.
+
+**Usage:** `/ciel-memory-bootstrap` (no args)
+
+This is **deterministic**: no agent dispatch, no pipeline, no DIVERGE/EVALUER. Just scan, propose, write on user confirmation.
+
+---
+
+## Instructions
+
+You are bootstrapping the cued-recall memory for this project. Follow these steps in order.
+
+### Step 1 — Scan
+
+Run the bootstrap script in `scan` mode:
+
+```bash
+# Try installed location first, fallback to dev location
+script="$CLAUDE_PROJECT_DIR/.claude/hooks/memory-bootstrap.sh"
+[ -f "$script" ] || script="$CLAUDE_PROJECT_DIR/hooks/memory-bootstrap.sh"
+bash "$script" scan
+```
+
+Or, if running on an installed Ciel: `bash "$HOME/.ciel/hooks/memory-bootstrap.sh" scan`.
+
+Report the output verbatim to the user.
+
+### Step 2 — Decide path
+
+Based on the scan output:
+
+- **If 0 sources found** → tell the user clearly: "No tribal docs to bootstrap from. The cued-recall memory will populate organically as you intervene with me. Nothing more to do." End here.
+- **If sources found** → proceed to Step 3.
+
+### Step 3 — Initialize structure
+
+Run:
+
+```bash
+script="$CLAUDE_PROJECT_DIR/.claude/hooks/memory-bootstrap.sh"
+[ -f "$script" ] || script="$CLAUDE_PROJECT_DIR/hooks/memory-bootstrap.sh"
+bash "$script" ingest
+```
+
+This creates `.ciel/memory/{episodes,concepts,guards}/` and an empty `index.json`. It does NOT auto-write memories — auto-ingestion would create cargo-cult entries from possibly-stale docs (see ADR-0001).
+
+### Step 4 — Read each source
+
+For each source found in Step 1, `Read` the file fully. Identify candidate memories:
+
+| Source format | What becomes a memory |
+|---|---|
+| `[YYYY-MM-DD] MISTAKE: X → RULE: Y` lines (lessons.md style) | One memory per line. Title = the rule. |
+| `## Heading\n\n- rule\n- rule` (rules.md style) | One memory per rule. |
+| Numbered lessons in `ciel-overlay.md` "Key Lessons" | One memory per lesson. |
+| `## section` in CLAUDE.md/AGENTS.md describing a non-obvious convention | One memory per section. |
+| **Claude Code auto-memory** entries (`~/.claude/projects/<slug>/memory/*.md`, excluding `MEMORY.md`) | One memory per file. Title = frontmatter `description`. Cues derived per "Auto-memory mapping" below. |
+
+#### Auto-memory mapping (special parser)
+
+Claude Code auto-memory uses a different frontmatter than Ciel's cued-recall. Each source file looks like:
+
+```yaml
+---
+name: feedback-okhttp-cookiejar-override
+description: Neiyomi shared PersistentCookieJar overrides manual Cookie headers via OkHttp BridgeInterceptor
+metadata:
+  type: feedback
+---
+
+(body markdown — Context / Why / How to apply sections)
+```
+
+When you encounter a file under `$AUTO_MEMORY_DIR`, map it to a Ciel episode as follows:
+
+| Auto-memory field | Ciel frontmatter field | Notes |
+|---|---|---|
+| `description:` | `title:` | one-line summary |
+| `name:` | base of slug for filename | already kebab-case |
+| `metadata.type:` (`user`/`feedback`/`project`/`reference`) | `intents:` `[<type>]` plus topic-specific intents inferred from body | e.g. `feedback` + `okhttp` + `cookie` |
+| body markdown | Ciel episode body, verbatim | preserve Context/Why/How to apply structure |
+| paths cited in body (e.g. `src/`, `*.kt`, `Caddyfile`) | `path_patterns:` | infer from grep — narrow patterns preferred |
+| symbols cited in body (class/function/table names) | `symbols:` | infer from grep |
+| language hint (file extensions in body) | `languages:` | `kotlin`/`typescript`/`python`/`sql`/etc. |
+| `captured_from:` (NEW) | `auto-memory-migration` | distinguishes from user-intervention captures |
+
+**Skip `MEMORY.md`** — it's a table-of-contents index, not memory content. The scan already excludes it.
+
+**Backup before delete.** After successfully writing an episode file for an auto-memory entry, MOVE (not delete) the source to `$AUTO_MEMORY_DIR/.migrated-to-ciel/<filename>` so the user can audit migration. The MEMORY.md index file itself stays in place — Claude Code may regenerate it on next session.
+
+Skip:
+- The pipeline / workflow descriptions (those belong in CLAUDE.md, not memory)
+- General principles already in CLAUDE.md
+- Anything that's just project description (READMEish)
+- Code examples (those go in skills/, not memory)
+
+### Step 5 — Propose batch capture
+
+Once you have N candidate memories from the sources, present them to the user **as a batch**, not one by one (avoid 50 confirmation prompts). Use a single `AskUserQuestion` with the structure:
+
+> "Found N candidates from your tribal docs. I'll list them; you tell me which to capture, which to skip, or 'all'."
+
+For each candidate, show:
+- **Title** (one line)
+- **Source** (file:line)
+- **Suggested tags** (paths, symbols, intents, language inferred from the lesson content)
+
+The user replies with: "all", "1,3,5,8" (specific indices), or "skip".
+
+### Step 6 — Write captured memories
+
+For each captured candidate, create `.ciel/memory/episodes/<YYYY-MM-DD>-<slug>.md` with frontmatter:
+
+```yaml
+---
+id: mem_<NNN>
+title: <title>
+languages: [<inferred>]
+path_patterns:
+  - <pattern>
+symbols: [<inferred>]
+intents: [<inferred>]
+captured_at: <ISO8601 now>
+captured_from: bootstrap
+source: <original-file:line>
+trigger_count: 0
+last_triggered: null
+stale_after_days: 90
+stale: false
+---
+
+# <title>
+
+<content from source, lightly cleaned>
+```
+
+ID strategy: read existing `index.json` for max id, increment. Slug = first 5 words of title, kebab-cased.
+
+### Step 7 — Rebuild index
+
+After all writes, regenerate `.ciel/memory/index.json` by parsing every frontmatter under `.ciel/memory/{episodes,concepts,guards}/`:
+
+```python
+# pseudo — use python3 -c '...' inline
+for each *.md file:
+    parse frontmatter
+    add to memories dict by id
+    for each path_pattern, symbol, intent, language:
+        append id to corresponding by_* index
+write back to index.json
+```
+
+### Step 8 — Confirm
+
+Report:
+
+- N memories captured
+- Sources processed
+- Index rebuilt with M total entries
+- Suggest: "Cued-recall memory now active. Memories will auto-inject when their cues match in future tasks. Run `/ciel-memory-bootstrap` again anytime to re-scan for new tribal docs."
+
+---
+
+## Constraints
+
+- **Never write a memory without user confirmation.** Even on bulk confirmation ("all"), display the list first.
+- **Do not delete the source files.** Bootstrap converts; the user keeps the originals as long as they want.
+- **Tag conservatively.** A memory tagged with `**/*` will fire on every task and pollute. If unsure, narrow the path pattern.
+- **No agent dispatch.** This command is deterministic and runs inline.
+- **Idempotent.** Re-running on an already-bootstrapped project should detect existing memories (by source field) and offer to skip duplicates.
+
+---
+
+## Failure modes
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| Script not found | `$CLAUDE_PROJECT_DIR` not set | Try `$HOME/.ciel/hooks/memory-bootstrap.sh` instead |
+| Nothing scanned | No tribal docs in this project | Working as intended; report and end |
+| Memories all tagged with broad paths | Source content didn't include path hints | Ask user to refine tags after listing |
+| index.json malformed after rebuild | python3 parse error | Recreate empty index, re-run rebuild step |
+| Auto-memory not detected | Slug derivation mismatch (cwd has unexpected characters) | Override via `CIEL_AUTO_MEMORY_DIR=<absolute-path> bash hooks/memory-bootstrap.sh scan` |
+| Auto-memory file has `name:` but no `description:` | Older auto-memory format | Use first heading or filename as title; ask user to confirm before writing |
+
+## See also
+
+- `docs/adrs/0001-cued-recall-memory.md` — full design rationale
+- `skills/workflow/memoire/SKILL.md` — capture/recall flow
+- `skills/workflow/memoire-consolidator/SKILL.md` — periodic maintenance

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`