@neikyun/ciel 6.2.4 → 6.4.0

package/assets/platforms/opencode/.opencode/commands/ciel-init.md

@@ -1,19 +1,173 @@
 ---
-command: ciel-init
-description: Initialize or reinstall Ciel in the current project
+description: ---
 subtask: false
 ---
 
-# /ciel-init — Initialize Ciel
+---
+description: Bootstrap or repair Ciel wiring. Auto-detects platform (Claude Code, OpenCode, Cursor, etc.) and configures hooks. Preserves existing config, creates backups.
+---
+
+# /ciel-init — Wire Ciel into Current Project
+
+**Purpose:** Fix the #1 Ciel failure mode — hooks not firing because config is missing, has wrong paths, or platform not detected.
+
+**Usage:** `/ciel-init [--check] [--user] [--platform=NAME]`
+
+- `--check` — Dry-run: show what would change without writing
+- `--user` — Install to user scope (~/.claude/settings.json) instead of project
+- `--platform=NAME` — Force platform (claude, opencode, cursor, windsurf, codex, kilocode, ollama, lmstudio)
+
+---
+
+## Instructions
+
+You are repairing Ciel wiring. This is deterministic — NO agent dispatch, NO research, NO pipeline.
+
+### Step 1: Detect Platform
+
+Run detection in order (pick FIRST match):
+
+1. **Project files:**
+   - `./opencode.json` or `./.opencode/` → **opencode**
+   - `./.claude/settings.json` or `./.claude/` → **claude**
+   - `./.cursor/` → **cursor**
+   - `./.windsurf/` → **windsurf**
+   - `./.codex/` → **codex**
+   - `./.kilocode/` or `./.kilo/` → **kilocode**
+
+2. **CLI availability:**
+   - `command -v claude` → **claude**
+   - `command -v opencode` → **opencode**
+   - `command -v ollama` → **ollama**
+
+3. **If ambiguous:** Ask user to specify with `--platform=NAME`
+
+### Step 2: Find Ciel Directory
+
+Check in order:
+1. `$CLAUDE_PLUGIN_DIR/ciel` (if env var set)
+2. `$HOME/.claude/plugins/ciel`
+3. `$HOME/.ciel`
+4. `find "$HOME" -maxdepth 5 -path '*/ciel/hooks/session-start.sh' 2>/dev/null | head -1`
+
+If not found → Tell user to run install first:
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/KaosKyun/Ciel/main/scripts/install.sh)
+```
+
+### Step 3: Verify Hooks Exist
+
+Check for 8 required hooks in `$CIEL_DIR/hooks/`:
+```
+session-start.sh, user-prompt-submit.sh, pre-tool-write.sh, post-tool-write.sh,
+stop.sh, subagent-stop.sh, pre-compact.sh, pre-agent-gate.sh
+```
+
+If missing → Copy from nearest Ciel source or tell user to reinstall.
+
+### Step 4: Configure Platform
+
+#### Claude Code Branch
+
+**Config file:** `./.claude/settings.json` (project) or `$HOME/.claude/settings.json` (user)
+
+**Before writing:**
+1. Check CWD sanity — warn if running Claude from different directory
+2. Backup existing config: `cp file.json file.json.bak-TIMESTAMP`
+
+**Write config:**
+```json
+{
+  "hooks": {
+    "SessionStart": { "command": "$CIEL_DIR/hooks/session-start.sh", "stdin": true },
+    "UserPromptSubmit": { "command": "$CIEL_DIR/hooks/user-prompt-submit.sh", "stdin": true },
+    "PreToolUse": { "command": "$CIEL_DIR/hooks/pre-tool-write.sh", "stdin": true, "matcher": "Write|Edit" },
+    "PostToolUse": { "command": "$CIEL_DIR/hooks/post-tool-write.sh", "stdin": true, "matcher": "Write|Edit" },
+    "PreCompact": { "command": "$CIEL_DIR/hooks/pre-compact.sh", "stdin": true },
+    "Stop": { "command": "$CIEL_DIR/hooks/stop.sh", "stdin": true }
+  }
+}
+```
+
+#### OpenCode Branch
+
+**Config file:** `./opencode.json`
+
+**Before writing:**
+1. Backup: `cp opencode.json opencode.json.bak-TIMESTAMP`
+2. Merge existing config (preserve model, provider, mcp, keybinds)
+
+**Ensure:**
+- `plugin` array contains `"./.opencode/plugins/ciel.ts"`
+- `instructions` array contains `"AGENTS.md"`
+
+**Copy files:**
+- `.opencode/plugins/ciel.ts`
+- `.opencode/agents/ciel-*.md` (6 files)
+- `.opencode/commands/ciel-*.md` (9 files)
+
+#### Other Platforms Branch
+
+Install platform-specific artifacts:
+- **Cursor:** `.cursor/rules/ciel.mdc`
+- **Windsurf:** `.windsurf/rules/*.md`
+- **Codex:** `AGENTS.md`, `.codex/hooks.json`
+- **Kilocode:** `.kilocode/rules/ciel.md`, `.kilo/agents/*`
+- **Ollama:** `Modelfile` (user runs `ollama create`)
+- **LM Studio:** `ciel.preset.json`, `system-prompt.md`
+
+### Step 5: Verification
+
+After configuration, verify:
+
+1. **Config file exists** at expected path
+2. **Hooks are executable:** `chmod +x "$CIEL_DIR/hooks/"*.sh`
+3. **Plugin file syntax valid** (for OpenCode: `npx tsc --noEmit`)
+
+### Step 6: Report
+
+Output summary:
+
+```
+✓ /ciel-init completed
+
+Platform: Claude Code
+Config: /path/to/settings.json
+CIEL_DIR: /path/to/ciel
+Hooks: 8/8 present
+
+Next steps:
+1. Restart Claude Code
+2. Run a test prompt — should see depth hint
+3. Make code changes — should see RELIRE reminder
+```
+
+---
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Ciel directory not found | Tell user to run install script |
+| Hooks missing | Try to copy from source, else reinstall |
+| Config write fails | Show manual instructions |
+| Platform ambiguous | Ask user to specify with --platform |
+| Permission denied | Suggest running with sudo or check file permissions |
+
+---
+
+## Examples
 
-Installs Ciel agents, hooks, and configuration for the current project. Detects OpenCode and/or Claude Code automatically.
+```bash
+# Auto-detect and install to project
+/ciel-init
 
-Usage: `/ciel-init`
+# Force Claude Code, user scope
+/ciel-init --platform=claude --user
 
-## What it does
+# Check what would change (dry-run)
+/ciel-init --check
 
-- Detects platform (OpenCode / Claude Code / both)
-- Copies agent definitions (`.opencode/agents/`)
-- Copies commands (`.opencode/commands/`)
-- Patches `opencode.json` with plugin reference
-- Creates `.ciel/` state directory
+# Force OpenCode
+/ciel-init --platform=opencode
+```

package/assets/platforms/opencode/.opencode/commands/ciel-migrate.md

@@ -0,0 +1,40 @@
+---
+description: ---
+subtask: false
+---
+
+---
+description: Migrates Ciel configuration between versions — updates CLAUDE.md format, skill references, hook wiring, and platform-specific configs. Supports v5→v6 migration (pipeline change, skill taxonomy reorganization). Non-destructive: backs up before any write.
+---
+
+# /ciel-migrate — Migrate Ciel Between Versions
+
+*Migrates project config from one Ciel version to another.*
+
+Usage: `/ciel-migrate [--dry-run] [--from=<version>] [--to=<version>]`
+
+- `--dry-run` — show what would change without writing
+- `--from=v5` — source version (auto-detected if absent)
+- `--to=v6` — target version (default: latest)
+
+## Supported migrations
+
+| From | To | Changes |
+|------|----|---------|
+| v5 | v6 | Update CLAUDE.md format (pipeline steps + depth gauge), update skill catalog in ciel/reference.md, rewire hooks if settings.json references old paths, update platform deploy templates |
+
+## Migration process
+
+1. Read current version from `.ciel/memory.json` `cielVersion` field
+2. Detect source version from config patterns
+3. Back up all files that will be modified (`.bak-<timestamp>`)
+4. Apply version-specific transformations
+5. Write new `.ciel/memory.json` with updated version
+6. Report summary of changes
+
+## Guardrails
+
+- **Always backs up before writing** — restore with `mv .bak-<timestamp>/* .`
+- **`--dry-run` is safe** — no files are touched
+- **Unknown version → abort** — don't guess the migration path
+- **One version hop at a time** — v5→v6, not v4→v6 directly

package/assets/platforms/opencode/.opencode/commands/ciel-refresh.md

@@ -1,20 +1,96 @@
 ---
-command: ciel-refresh
-description: Freshness audit over the skill library
-agent: ciel-improver
-subtask: true
+description: ---
+subtask: false
 ---
 
-# /ciel-refresh — Freshness audit
+---
+description: Scans every Ciel skill for stale external references (outdated library version pins, dead URLs, superseded research citations) and produces a freshness patch-set for user approval. Complements `/ciel-improve` (transcript-driven) by catching drift from the outside world.
+---
+
+# /ciel-refresh — Freshness audit over the skill library
+
+*Runs the `skill-freshness-auditor` meta-skill to surface stale external references across every Ciel skill and propose concrete updates.*
+
+Usage: `/ciel-refresh [scope] [--force]`
+
+- `scope` defaults to `all`. Other scopes: `workflow`, `research`, `domain`, `utility`, `meta`, `ciel`, or a specific skill name like `skill=debug-reasoning-rca`.
+- `--force` bypasses the 18-month URL cache (re-checks every reference even if it was checked recently).
+
+---
+
+## What it does
+
+1. Enumerates every `SKILL.md` and `reference.md` under `$CIEL_DIR/skills/` (or the filtered scope).
+2. Extracts three categories of external refs:
+   - **URLs** (any `http(s)://...`)
+   - **Library + version pins** (e.g., `Playwright 1.49`, `React 19`, `Ktor 3.1`)
+   - **Research citations** (e.g., `STRATUS 2024`, `ThoughtWorks Tech Radar April 2026`, `OWASP Top 10`, `WCAG 2.2`)
+3. For each ref, runs a freshness check:
+   - URL → `WebFetch` to confirm 200 OK + Last-Modified within the window
+   - Library → `WebSearch` for latest stable, compare to the pinned version
+   - Citation → `WebSearch` for a named superseding work
+4. Produces a `freshness patch-set` — one entry per stale ref, with severity HIGH/MEDIUM/LOW and a proposed rewrite.
+5. Waits for user approval on each patch (`[y/n/edit]`), then applies only the approved ones.
+6. Logs the audit to `$CIEL_DIR/.freshness-log.jsonl` so future runs can skip refs that were checked recently.
+
+---
+
+## Severity levels
+
+| Severity | Trigger | Example |
+|---|---|---|
+| **HIGH** | Broken (404 URL, removed-from-npm library) | `https://defunct-docs.example.com/api` returns 404 |
+| **MEDIUM** | Outdated (lib 1 major behind, URL redirecting away) | Skill pins `Playwright 1.49`, latest is `2.3` |
+| **LOW** | Minor drift (minor-version gap, citation 2-3 years old) | Skill cites `OWASP Top 10 2021`, current is `2025` |
+
+---
 
-Scans every Ciel skill for stale external references (outdated library version pins, dead URLs, superseded research citations) and produces a freshness patch-set for user approval.
+## Output example
 
-Usage: `/ciel-refresh`
+```
+# Ciel freshness audit — 2026-04-17T14:30Z
+
+Skills scanned: 48
+References extracted: 127  (URLs: 62, libs: 44, citations: 21)
+Cache hits (recent): 41
+Network checks performed: 86
+Findings: HIGH 2, MEDIUM 5, LOW 3
+
+## Patch 1 — skills/workflow/playwright-visual-critic/SKILL.md — FRESHNESS-lib
+Reference: `Playwright 1.49` at line 28
+Finding: Latest stable is Playwright 2.3.1 (released 2026-02) — 2 majors behind.
+Severity: MEDIUM
+
+--- BEFORE (line 28)
+Uses Playwright 1.49 MCP server for browser automation.
+--- AFTER (proposed)
+Uses Playwright 2.3.1 MCP server for browser automation (breaking changes vs 1.x: see https://playwright.dev/docs/release-notes#2.0).
+
+Approve? [y/n/edit]
+```
+
+---
+
+## When to run
+
+- **Monthly routine** — drift accumulates silently; a batched pass keeps it bounded.
+- **Before a major version bump** — so the new release ships without stale pins.
+- **After a major upstream release** (Claude Code, OpenCode, Anthropic API) — their docs URLs may have moved.
+- **After a long quiet period** on a specific skill — add `scope=skill=<name>` to hit just that one.
+
+Avoid running on every task — a full scan burns ~1-3K tokens per skill (WebFetch + WebSearch).
+
+---
+
+## Cost
+
+Typical full run (~50 skills) consumes 100-300K tokens depending on how many cached vs new checks. Cheaper after the first run (cache hits dominate). Projected cost is displayed before the network phase — abortable.
+
+---
 
-## Process
+## Relation to other `/ciel-*` commands
 
-1. Lists all skills from `skills/`
-2. For each skill, checks external references
-3. Flags outdated URLs, version pins, citations
-4. Produces patch-set for user approval
-5. Never rewrites autonomously
+- **`/ciel-improve`** — transcript-driven; catches what Ciel *experienced*. `/ciel-refresh` catches what *changed outside* Ciel.
+- **`/ciel-eval`** — benchmarks skill variants on fixed datasets. `/ciel-refresh` doesn't grade quality, just currency.
+- **`/ciel-audit`** — session-level violations. `/ciel-refresh` is library-level drift.
+- **`/ciel-create-skill`** — scaffolds new. `/ciel-refresh` updates existing.

package/assets/platforms/opencode/.opencode/commands/ciel-status.md

@@ -0,0 +1,45 @@
+---
+description: ---
+subtask: false
+---
+
+---
+description: Displays the current Ciel environment status — active version, loaded skills, registered hooks, last session state, and configuration health. A diagnostic entry point for "is Ciel working?" questions.
+---
+
+# /ciel-status — Ciel Environment Health Check
+
+*Displays the current Ciel environment status: version, skills, hooks, and config.*
+
+Usage: `/ciel-status [--check]`
+
+- `--check` — run diagnostics (verify hooks fire, skills load, config is valid)
+
+## Output
+
+```
+## CIEL STATUS
+
+Version: v6.2.4
+Platform: Claude Code
+Config: .claude/settings.json — OK (4 hooks registered)
+Skills directory: skills/ — 43 skills loaded
+Commands: 7 commands available
+Last session: 2026-05-06T11:20:00Z — Skills library reorg
+```
+
+## Diagnostics (--check)
+
+- [ ] CLAUDE.md readable and includes Ciel pipeline
+- [ ] .claude/settings.json valid JSON, hooks registered
+- [ ] .ciel/map.json parseable and up-to-date
+- [ ] .ciel/memory.json parseable
+- [ ] Shell hooks executable (check-test-first, block-destructive, track-file, meta-critiquer)
+- [ ] Skills directory non-empty and accessible
+- [ ] Agent definitions present (.claude/agents/ or .opencode/agents/)
+
+## When triggered
+
+- User asks "is Ciel working?" or "check Ciel health"
+- After ciel-init to verify installation
+- Debugging hook failures or missing depth classification

package/assets/platforms/opencode/.opencode/commands/ciel-update.md

@@ -1,50 +1,63 @@
 ---
-description: Update Ciel to the latest version via NPM. Checks NPM registry, updates global package, force-reinstalls in project.
+description: ---
+subtask: false
+---
+
+---
+description: Check GitHub for newer Ciel release and re-install. Runs `scripts/install.sh --check-update` then `--update`.
 ---
 
 # /ciel-update — Update Ciel to the latest version
 
+Checks GitHub for a newer release and re-installs if available.
+
 ## Steps
 
-### Global install (recommended)
+1. **Check version**: `bash scripts/install.sh --check-update`
+   - Fetches `VERSION` from GitHub, compares with local
+   - Prints "up to date" or "update available"
 
-```bash
-# 1. Check
-ciel check
+2. **Apply update**: `bash scripts/install.sh --update -y`
+   - Re-installs all Ciel files (plugins, agents, commands, hooks)
+   - Preserves: `ciel-overlay.md`, `.ciel/`, existing configs
+   - Non-destructive merge on `opencode.json`
 
-# 2. Update global package
-npm update -g @neikyun/ciel
+## Flags
 
-# 3. Force reinstall in project (new plugin JS, agents, commands, hooks)
-ciel update
-```
+| Flag | Purpose |
+|------|---------|
+| `--check-update` | Check remote version, don't install |
+| `--update` / `-u` | Force reinstall all files |
+| `-y` | Skip confirmation (non-interactive) |
+| `-q` | Quiet mode (summary only) |
 
-### Project-local install
+## One-liner
 
 ```bash
-npm update @neikyun/ciel   # postinstall auto-updates everything
+bash <(curl -fsSL https://raw.githubusercontent.com/KaosKyun/Ciel/main/scripts/install.sh) --check-update
+bash <(curl -fsSL https://raw.githubusercontent.com/KaosKyun/Ciel/main/scripts/install.sh) --update -y
 ```
 
 ## What's preserved
 
 - `ciel-overlay.md` — project-specific rules
-- `.ciel/map.json`, `.ciel/memory.json`, `.ciel/parking.md` — persistent state
-- `opencode.json` — existing config patched non-destructively
+- `.ciel/map.json`, `.ciel/memory.json`, `.ciel/parking.md`
+- `opencode.json` — existing config merged non-destructively
+- `.claude/settings.json` — hook paths preserved
 
 ## What's replaced
 
-- `.opencode/plugins/ciel.js` — compiled plugin
+- `.opencode/plugins/ciel.ts` — fresh plugin
 - `.opencode/agents/ciel-*.md` — agent definitions
 - `.opencode/commands/ciel-*.md` — command files
 - `.claude/agents/ciel-*.md` — Claude Code agents
 - `.claude/hooks/*.sh` — shell hooks
 - `CLAUDE.md` — root instruction
-- `.claude/settings.json` — hook config
 
 ## Troubleshooting
 
 | Symptom | Fix |
 |---------|-----|
+| `Could not fetch remote version` | Check internet or proxy: `https_proxy=... bash install.sh --check-update` |
 | Plugin not loaded after update | Restart OpenCode (plugin loaded at session start) |
-| `ciel: command not found` | Reinstall globally: `npm install -g @neikyun/ciel` |
-| NPM registry unreachable | Check internet or proxy: `HTTPS_PROXY=... ciel check` |
+| `jq not found` warning | Install jq for automatic opencode.json patching |

package/assets/platforms/opencode/.opencode/commands/ciel.md

@@ -1,6 +1,5 @@
 ---
-command: ciel
-description: Ciel orchestrator — full 16-step deep-reasoning pipeline
+description: Slash trigger for the Ciel orchestrator skill on OpenCode.
 ---
 
 Invoke the `ciel` skill via the Skill tool with the user's arguments:

package/assets/platforms/opencode/.opencode/plugins/ciel.ts

@@ -0,0 +1,146 @@
+// Ciel — OpenCode plugin (v6.2.4)
+// Ciel v5 plugin. Pure TS, no shell dependency.
+//
+// Injection model (verified against @opencode-ai/plugin/dist/index.d.ts):
+//   - experimental.chat.system.transform → push depth hint + sticky RELIRE
+//     notice into the system-prompt array each turn. Both are visible to
+//     the model on the following turn.
+//   - tool.execute.after (write|edit)    → append a per-file FAIRE/RELIRE
+//     reminder to the tool result string so the model reads it on its
+//     next turn attached to that tool call.
+//   - session.created (event)            → console banner only (no
+//     model-visible injection needed at session start).
+//
+// Why not tool.execute.before? Its output shape is { args } only — no way
+// to inject context, and console.log goes to terminal/plugin log, not the
+// model.
+//
+// Why not chat.params? Its output has no `system` field; pushing to it
+// is a silent no-op. Depth hints belong in experimental.chat.system.transform.
+//
+// The experimental.* hooks may shift between OpenCode releases. Regenerate
+// this file with `scripts/build-platforms.sh --target=opencode` after any
+// upstream plugin API change.
+
+import type { Plugin } from "@opencode-ai/plugin";
+
+const CODE_EXT_RE = /\.(kt|java|ts|tsx|js|jsx|py|go|rs|rb|php|cs|cpp|c|swift|scala|vue|svelte|sql)$/i;
+const CRITICAL_FILE_RE = /(auth|Auth|security|Security|Route|Service|Controller|Repository|Gateway|Middleware|Proxy|Token|Session|Password|Secret)/;
+const CRITICAL_KEYWORD_RE = /\b(auth|authenti|author|jwt|oauth|password|secret|token|session|payment|credit.card|migration.*schema|2fa|mfa|encryption|credential|cookie.*security)\b/i;
+const TRIVIAL_KEYWORD_RE = /\b(rename|typo|copyright|comment|readme|1-line|one.line|fix.typo|spelling)\b/i;
+
+const ciel: Plugin = async ({ $ }) => {
+  // Per-session state. Reset when the plugin module is re-instantiated
+  // (once per OpenCode session).
+  const writtenFiles = new Set<string>();
+  const remindedFiles = new Set<string>();
+  let relireSticky = false; // once true, every turn re-injects the RELIRE notice
+  let lastDepthHint: string | null = null;
+
+  // v3.3.0 — dispatch-gate counter removed. The per-call [CIEL COUNTER: N/15]
+  // systemMessage was pure noise on every inline tool call. Depth routing
+  // still happens via experimental.chat.system.transform + the sticky
+  // RELIRE notice; users dispatch @ciel-* explicitly when they need one.
+
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        // Terminal-only banner. Model context is handled by the transform hook.
+        console.log("[CIEL] Session started — depth-aware reasoning active. Use /ciel, @ciel-researcher, @ciel-explorer, @ciel-critic.");
+      }
+    },
+
+    // Per-turn system-prompt injection. This hook runs on every model turn
+    // so we get a reliable "inject once per turn" surface without having to
+    // manage cross-hook message state ourselves.
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (lastDepthHint && Array.isArray(output?.system)) {
+        output.system.push(lastDepthHint);
+      }
+      if (relireSticky && Array.isArray(output?.system)) {
+        const changed = Array.from(writtenFiles);
+        output.system.push(
+          `[CIEL RELIRE REQUIRED] ${changed.length} code files changed this session (${changed.slice(0, 6).join(", ")}${changed.length > 6 ? ", ..." : ""}). Dispatch @ciel-critic MODE=RELIRE — 3 RISQUES + FIX/ACCEPT/DEFER. Do not declare done before verdict.`
+        );
+      }
+    },
+
+    // Full message-list transform — read the most recent user text and
+    // reclassify depth every turn. Keeps lastDepthHint fresh; the actual
+    // injection happens in the system.transform hook above.
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const msgs = output?.messages;
+      if (!Array.isArray(msgs) || msgs.length === 0) return;
+      // Find the most recent user text part.
+      let prompt = "";
+      for (let i = msgs.length - 1; i >= 0 && !prompt; i--) {
+        const m = msgs[i];
+        if (m?.info?.role !== "user") continue;
+        const parts = m?.parts;
+        if (!Array.isArray(parts)) continue;
+        for (let j = parts.length - 1; j >= 0; j--) {
+          const p = parts[j];
+          if (p?.type === "text" && typeof p.text === "string") {
+            prompt = p.text;
+            break;
+          }
+        }
+      }
+      if (!prompt) return;
+
+      let depth: string | null = null;
+      let reason = "";
+      if (CRITICAL_KEYWORD_RE.test(prompt)) {
+        depth = "Critical";
+        reason = "auth/security/payment keyword detected";
+      } else if (TRIVIAL_KEYWORD_RE.test(prompt)) {
+        depth = "Trivial";
+        reason = "rename/typo/docs keyword detected";
+      }
+      lastDepthHint = depth
+        ? `[CIEL] Depth: ${depth} (${reason}). Route the pipeline accordingly.`
+        : null;
+    },
+
+    tool: {
+      execute: {
+        // Append FAIRE/RELIRE reminder to the tool result text. OpenCode's
+        // tool.execute.after output is { title, output, metadata } — the
+        // `output` field is the tool result string surfaced to the model.
+        // Mutation here is the ONLY way to inject per-tool context.
+        after: async (input, output) => {
+          if (!["write", "edit"].includes(input.tool)) return;
+          const args: any = (input as any).args ?? {};
+          const filePath: string = args.file_path ?? args.path ?? "";
+          if (!filePath || !CODE_EXT_RE.test(filePath)) return;
+
+          writtenFiles.add(filePath);
+
+          const isCritical = CRITICAL_FILE_RE.test(filePath);
+          if (writtenFiles.size >= 5 || isCritical) {
+            relireSticky = true;
+          }
+
+          // Per-file FAIRE reminder fires once per path to avoid burning
+          // ~50 tokens × N edits on the same file.
+          if (remindedFiles.has(filePath)) return;
+          remindedFiles.add(filePath);
+
+          const reminder = isCritical
+            ? `\n\n[CIEL CRITIQUE] ${filePath} — FAIRE gates + stride-analyzer + flux-narrator + test-first (RED). Dispatch @ciel-critic MODE=RELIRE before declaring done.`
+            : `\n\n[CIEL] ${filePath} — FAIRE gates: alternatives, idiomatic, test-first. Ensure @ciel-researcher + @ciel-explorer ran.`;
+
+          if (typeof output?.output === "string") {
+            output.output += reminder;
+          } else if (output) {
+            // Defensive: if output.output is missing/nullish, create it so
+            // the reminder still lands on the model.
+            (output as any).output = reminder.trimStart();
+          }
+        },
+      },
+    },
+  };
+};
+
+export default ciel;

package/assets/platforms/opencode/AGENTS.md

@@ -1,4 +1,4 @@
-# AGENTS.md — Ciel deep-reasoning workflow (OpenCode, v3.3.0)
+# AGENTS.md — Ciel deep-reasoning workflow (OpenCode, v6.2.4)
 
 Source: https://github.com/KaosKyun/Ciel
 
@@ -16,7 +16,7 @@ Ciel is installed as OpenCode-native primitives:
 
 | Level | Example | Pipeline |
 |-------|---------|----------|
-| **Trivial** | rename, typo, 1-line fix | `quoi-framer` → `pattern-fitness-check` → `faire-gatekeeper` → inline review → push |
+| **Trivial** | rename, typo, 1-line fix | `QUOI` → `FAIRE` → `META` |
 | **Standard** | hook, route, component, service | Full pipeline, dispatch `@ciel-researcher` + `@ciel-explorer` in parallel before coding |
 | **Critical** | auth, DB schema, security, payment | Full pipeline + STRIDE threat model + `@ciel-critic` mandatory |