@neikyun/ciel 6.8.0 → 6.9.0

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

@@ -0,0 +1,99 @@
+#!/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)
+
+# 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"
+
+MSG="CIEL v6.8.0 — 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/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/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,78 @@ 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
+OPENCODE_PLUGIN=$(test -f .opencode/plugins/ciel.ts && 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.ts plugin + 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 +167,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 +183,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 +232,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 +262,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 +273,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 +359,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.

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

@@ -0,0 +1,160 @@
+---
+description: Scan project for ingestable tribal docs (lessons.md, ciel-overlay.md, .claude/rules/, 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/`, 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. |
+
+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 |
+
+## 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/commands/ciel-status.md

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

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

@@ -6,7 +6,7 @@ temperature: 0.2
 tools:
   write: false
   edit: false
-  bash: false
+  bash: true
   read: true
   glob: true
   grep: true

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

@@ -4,8 +4,8 @@ mode: subagent
 model: anthropic/claude-sonnet-4-6
 temperature: 0.2
 tools:
-  write: false
-  edit: false
+  write: true
+  edit: true
   bash: true
   read: true
   glob: true

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

@@ -6,7 +6,7 @@ temperature: 0.2
 tools:
   write: false
   edit: false
-  bash: false
+  bash: true
   read: true
   glob: false
   grep: false