openclaw-cortex-memory 0.1.0-Alpha.9 → 0.1.1

package/scripts/repair-memory.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const isDryRun = args.includes('--dry-run');
+const isFix = args.includes('--fix');
+const targetArg = args.find(a => a.startsWith('--target='));
+const target = targetArg ? targetArg.split('=')[1] : 'all';
+
+const PROJECT_ROOT = process.cwd();
+const MEMORY_ROOT = path.join(PROJECT_ROOT, 'data', 'memory');
+
+const VALID_TARGETS = ['all', 'archive', 'active', 'vector'];
+
+function printUsage() {
+  console.log(`
+Memory Data Repair Tool
+
+Usage: node scripts/repair-memory.js [options]
+
+Options:
+  --dry-run          Scan and report issues without making changes
+  --fix              Remove invalid records and create quarantine file
+  --target=<target>  Specify target: all, archive, active, vector (default: all)
+
+Examples:
+  node scripts/repair-memory.js --dry-run
+  node scripts/repair-memory.js --fix --target=archive
+`);
+}
+
+if (!VALID_TARGETS.includes(target)) {
+  console.error(`Invalid target: ${target}. Valid targets: ${VALID_TARGETS.join(', ')}`);
+  printUsage();
+  process.exit(1);
+}
+
+if (!isDryRun && !isFix) {
+  printUsage();
+  process.exit(0);
+}
+
+function validateJsonlLine(line, lineNumber) {
+  const errors = [];
+  if (!line || !line.trim()) {
+    return { valid: true, errors: [], record: null };
+  }
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch (e) {
+    errors.push(`JSON parse error: ${e.message}`);
+    return { valid: false, errors, record: null };
+  }
+  if (!record || typeof record !== 'object') {
+    errors.push('Record is not an object');
+    return { valid: false, errors, record: null };
+  }
+  if (typeof record.id !== 'string' || !record.id.trim()) {
+    errors.push('Missing or invalid id field');
+  }
+  if (typeof record.timestamp !== 'string' || !record.timestamp.trim()) {
+    errors.push('Missing or invalid timestamp field');
+  }
+  if (record.layer !== 'active' && record.layer !== 'archive') {
+    errors.push('Missing or invalid layer field');
+  }
+  const anomalyPatterns = [
+    /\d+\.\d+,\s*"[^"]+"/,
+    /"[^"]+"\s+\d+\.\d+/,
+    /,\s*\d+\.\d+,/,
+    /"\w+\.\w+\.\w+"/,
+    /\d+\.\w+\.\d+/,
+  ];
+  const lineStr = JSON.stringify(record);
+  for (const pattern of anomalyPatterns) {
+    if (pattern.test(lineStr)) {
+      errors.push('Anomaly pattern detected in record');
+      break;
+    }
+  }
+  return { valid: errors.length === 0, errors, record };
+}
+
+function scanJsonlFile(filePath) {
+  const results = {
+    path: filePath,
+    exists: false,
+    totalLines: 0,
+    validLines: 0,
+    invalidLines: 0,
+    emptyLines: 0,
+    issues: [],
+  };
+  if (!fs.existsSync(filePath)) {
+    return results;
+  }
+  results.exists = true;
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) {
+      results.emptyLines++;
+      continue;
+    }
+    results.totalLines++;
+    const validation = validateJsonlLine(line, i + 1);
+    if (validation.valid) {
+      results.validLines++;
+    } else {
+      results.invalidLines++;
+      results.issues.push({
+        lineNumber: i + 1,
+        errors: validation.errors,
+        preview: line.slice(0, 100) + (line.length > 100 ? '...' : ''),
+      });
+    }
+  }
+  return results;
+}
+
+function repairJsonlFile(filePath, dryRun) {
+  const results = {
+    path: filePath,
+    exists: false,
+    totalLines: 0,
+    validLines: 0,
+    removedLines: 0,
+    quarantineLines: [],
+  };
+  if (!fs.existsSync(filePath)) {
+    return results;
+  }
+  results.exists = true;
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split(/\r?\n/);
+  const validRecords = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) {
+      continue;
+    }
+    results.totalLines++;
+    const validation = validateJsonlLine(line, i + 1);
+    if (validation.valid) {
+      results.validLines++;
+      validRecords.push(line);
+    } else {
+      results.removedLines++;
+      results.quarantineLines.push({
+        lineNumber: i + 1,
+        content: line,
+        errors: validation.errors,
+      });
+    }
+  }
+  if (!dryRun && results.removedLines > 0) {
+    const newContent = validRecords.join('\n') + (validRecords.length > 0 ? '\n' : '');
+    fs.writeFileSync(filePath, newContent, 'utf-8');
+    const quarantinePath = filePath + '.quarantine.jsonl';
+    const quarantineContent = results.quarantineLines.map(q => 
+      JSON.stringify({ lineNumber: q.lineNumber, errors: q.errors, content: q.content })
+    ).join('\n');
+    fs.writeFileSync(quarantinePath, quarantineContent + '\n', 'utf-8');
+  }
+  return results;
+}
+
+function scanVectorFallback(filePath) {
+  const results = {
+    path: filePath,
+    exists: false,
+    totalRecords: 0,
+    validRecords: 0,
+    orphanRecords: 0,
+    issues: [],
+  };
+  if (!fs.existsSync(filePath)) {
+    return results;
+  }
+  results.exists = true;
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    results.totalRecords++;
+    try {
+      const record = JSON.parse(line);
+      if (!record.id || !record.embedding) {
+        results.issues.push({
+          lineNumber: i + 1,
+          error: 'Missing id or embedding',
+        });
+      } else {
+        results.validRecords++;
+      }
+    } catch (e) {
+      results.issues.push({
+        lineNumber: i + 1,
+        error: `JSON parse error: ${e.message}`,
+      });
+    }
+  }
+  return results;
+}
+
+console.log('='.repeat(60));
+console.log('Memory Data Repair Tool');
+console.log('='.repeat(60));
+console.log(`Mode: ${isDryRun ? 'DRY RUN (no changes)' : 'FIX (will modify files)'}`);
+console.log(`Target: ${target}`);
+console.log(`Memory Root: ${MEMORY_ROOT}`);
+console.log('='.repeat(60));
+
+const archivePath = path.join(MEMORY_ROOT, 'sessions', 'archive', 'archive.jsonl');
+const activePath = path.join(MEMORY_ROOT, 'sessions', 'active', 'sessions.jsonl');
+const vectorFallbackPath = path.join(MEMORY_ROOT, 'vector', 'lancedb_events.jsonl');
+
+let totalIssues = 0;
+const report = {
+  archive: null,
+  active: null,
+  vector: null,
+};
+
+if (target === 'all' || target === 'archive') {
+  console.log('\n[Archive Layer]');
+  if (isDryRun) {
+    report.archive = scanJsonlFile(archivePath);
+  } else {
+    report.archive = repairJsonlFile(archivePath, false);
+  }
+  if (!report.archive.exists) {
+    console.log('  File does not exist');
+  } else {
+    console.log(`  Total lines: ${report.archive.totalLines}`);
+    console.log(`  Valid lines: ${report.archive.validLines}`);
+    console.log(`  Invalid lines: ${report.archive.invalidLines || report.archive.removedLines}`);
+    if (report.archive.issues && report.archive.issues.length > 0) {
+      console.log('  Issues found:');
+      report.archive.issues.slice(0, 5).forEach(issue => {
+        console.log(`    Line ${issue.lineNumber}: ${issue.errors.join(', ')}`);
+      });
+      if (report.archive.issues.length > 5) {
+        console.log(`    ... and ${report.archive.issues.length - 5} more`);
+      }
+    }
+    totalIssues += report.archive.invalidLines || report.archive.removedLines || 0;
+  }
+}
+
+if (target === 'all' || target === 'active') {
+  console.log('\n[Active Layer]');
+  if (isDryRun) {
+    report.active = scanJsonlFile(activePath);
+  } else {
+    report.active = repairJsonlFile(activePath, false);
+  }
+  if (!report.active.exists) {
+    console.log('  File does not exist');
+  } else {
+    console.log(`  Total lines: ${report.active.totalLines}`);
+    console.log(`  Valid lines: ${report.active.validLines}`);
+    console.log(`  Invalid lines: ${report.active.invalidLines || report.active.removedLines}`);
+    if (report.active.issues && report.active.issues.length > 0) {
+      console.log('  Issues found:');
+      report.active.issues.slice(0, 5).forEach(issue => {
+        console.log(`    Line ${issue.lineNumber}: ${issue.errors.join(', ')}`);
+      });
+      if (report.active.issues.length > 5) {
+        console.log(`    ... and ${report.active.issues.length - 5} more`);
+      }
+    }
+    totalIssues += report.active.invalidLines || report.active.removedLines || 0;
+  }
+}
+
+if (target === 'all' || target === 'vector') {
+  console.log('\n[Vector Fallback]');
+  report.vector = scanVectorFallback(vectorFallbackPath);
+  if (!report.vector.exists) {
+    console.log('  File does not exist');
+  } else {
+    console.log(`  Total records: ${report.vector.totalRecords}`);
+    console.log(`  Valid records: ${report.vector.validRecords}`);
+    console.log(`  Issues: ${report.vector.issues.length}`);
+    if (report.vector.issues.length > 0) {
+      console.log('  Issues found:');
+      report.vector.issues.slice(0, 5).forEach(issue => {
+        console.log(`    Line ${issue.lineNumber}: ${issue.error}`);
+      });
+    }
+    totalIssues += report.vector.issues.length;
+  }
+}
+
+console.log('\n' + '='.repeat(60));
+console.log('Summary');
+console.log('='.repeat(60));
+console.log(`Total issues found: ${totalIssues}`);
+
+if (isDryRun) {
+  if (totalIssues > 0) {
+    console.log('\nRun with --fix to repair these issues.');
+  } else {
+    console.log('\nNo issues found. Memory data is healthy.');
+  }
+} else {
+  if (totalIssues > 0) {
+    console.log('\nRepair completed. Invalid records have been quarantined.');
+    console.log('Check .quarantine.jsonl files for removed records.');
+  } else {
+    console.log('\nNo repairs needed. Memory data is healthy.');
+  }
+}
+
+process.exit(totalIssues > 0 && isDryRun ? 1 : 0);

package/skills/cortex-memory/SKILL.md

@@ -0,0 +1,83 @@
+# Openclaw Cortex Memory
+
+OpenClaw 长期记忆插件，专为 OpenClaw AI 助手设计的智能记忆系统。
+
+面向 OpenClaw 的长期记忆插件，集成多路检索、事件归档、图谱关系、向量化与反衰减排序，支持历史增量导入、规则反思和可观测诊断，可以将会话中零碎的记忆去噪整理、分层存储，支持对话中自动搜索回忆，吸收了 LLM wiki 的概念，帮助 Agent 在跨会话中持续积累并稳定调用高价值记忆。
+
+## 核心能力
+
+### 1) 语义检索
+- 多路召回：`keyword / BM25 / vector / graph` 混合检索
+- 排序融合：加权打分 + RRF + 可选 reranker
+- 结果融合：可选 `readFusion`，支持权威融合返回
+- 时序建模：`memoryDecay` + 命中反衰减（anti-decay）
+
+### 2) 事件存储
+- 分层写入：`active`（会话）与 `archive`（结构化事件）
+- 摘要优先：归档记录保留 `summary` 与 `source_text`
+- 向量分块：支持 summary/evidence 双通道向量记录
+- 增量同步：按状态文件增量导入历史会话
+
+### 3) 图谱关系
+- 图谱独立层：`graph/memory.jsonl` 独立于 archive 文本层
+- 关系追溯：每条关系可追溯 `source_event_id`
+- 关系查询：`query_graph` 支持方向、关系类型、路径搜索
+- 冲突治理：单值事实冲突进入队列，支持人工 `accept/reject` 闭环
+- 可视化导出：`export_graph_view` 输出状态化图谱快照（含来源证据）
+- 质量门禁：全局 `graphQualityMode` 支持 `off/warn/strict`；历史导入可用 `syncPolicy.graphQualityMode` 单独收紧
+
+### 4) 规则演进
+- 反思沉淀：`reflect_memory` 将事件抽象为规则
+- 去重治理：规则与事件均有去重控制，避免污染
+- 规则复用：规则写入 `CORTEX_RULES.md` 供后续任务复用
+
+### 5) 运维诊断
+- `cortex_diagnostics`：模型连通、层级状态、字段对齐检查
+- `backfill_embeddings`：支持 `incremental / vector_only / full`
+- `lint_memory_wiki`：Wiki/图谱一致性、证据完整性与知识页质量巡检
+- 完整状态文件：便于快速定位同步、回填、质量问题
+
+---
+name: cortex-memory
+description: Independent skill for Cortex Memory operations in OpenClaw. Use when users ask for cross-session memory continuity, prior decisions, preferences, relationship tracing, or memory maintenance. If the memory plugin is not installed, guide users to install and enable openclaw-cortex-memory first, then continue with normal memory workflows.
+homepage: https://github.com/deki18/openclaw-cortex-memory
+metadata: { "openclaw": { "os": ["darwin", "linux", "win32"], "primaryEnv": "EMBEDDING_API_KEY" } }
+---
+
+Use this runtime flow:
+
+1. Check whether plugin `openclaw-cortex-memory` is available.
+2. If missing or disabled, run the install bootstrap guide in `{baseDir}/references/agent-manual.md` with README-consistent install order.
+3. After plugin is enabled, run memory retrieval or write operations.
+
+After plugin is ready, use this default workflow:
+
+1. Retrieve candidate memory with `search_memory`.
+2. If the user asks about entity links or dependency paths, use `query_graph`.
+3. If `query_graph` returns `conflict_hint`, use `list_graph_conflicts` and ask user confirmation before `resolve_graph_conflict`.
+4. For graph status snapshots or projection consistency checks, use `export_graph_view` and `lint_memory_wiki`.
+5. Answer with retrieved evidence first, then add reasoning.
+6. If the turn introduces durable new information, persist it with `store_event`.
+7. For maintenance windows or session wrap-up, run `sync_memory` and optionally `reflect_memory`.
+
+If tool calls fail:
+
+1. Check plugin availability first (`openclaw plugins list` / `openclaw plugins inspect openclaw-cortex-memory`).
+2. If visible, run `cortex_diagnostics` (or legacy alias `diagnostics`).
+3. Tell the user the plugin is unavailable or misconfigured.
+4. Continue with a normal answer without fabricating memory hits.
+
+Do not use this skill for:
+
+- Real-time web facts (weather, stock, breaking news).
+- One-off temporary context that should not be persisted.
+
+Use these local references when needed:
+
+- Install and bootstrap playbook: `{baseDir}/references/agent-manual.md`
+- System prompt template: `{baseDir}/references/system-prompt-template.md`
+- Tool details: `{baseDir}/references/tools.md`
+- Config and dependency setup: `{baseDir}/references/configuration.md`
+- Publish and validation checklist: `{baseDir}/references/publish-checklist.md`
+
+For environment preflight, use `{baseDir}/references/publish-checklist.md`.

package/skills/cortex-memory/references/agent-manual.md

@@ -0,0 +1,127 @@
+# Cortex Memory Agent Manual
+
+## Goal
+
+Use Cortex Memory as a long-term memory layer in OpenClaw. This manual is for agents operating from the independent `cortex-memory` skill folder.
+
+## Phase 1: Plugin Availability Check
+
+Run:
+
+```bash
+openclaw plugins list
+openclaw plugins inspect openclaw-cortex-memory
+```
+
+If plugin exists and is enabled, continue to Phase 3.
+
+If plugin is missing or disabled, go to Phase 2.
+
+## Phase 2: Install and Enable Plugin
+
+Preferred install path (README default):
+
+```bash
+openclaw plugins install clawhub:openclaw-cortex-memory
+openclaw plugins enable openclaw-cortex-memory
+```
+
+Fallback install path:
+
+```bash
+npm pack openclaw-cortex-memory@0.1.0-Alpha.34
+openclaw plugins install ./openclaw-cortex-memory-0.1.0-Alpha.34.tgz
+openclaw plugins enable openclaw-cortex-memory
+rm ./openclaw-cortex-memory-0.1.0-Alpha.34.tgz
+```
+
+Then verify:
+
+```bash
+openclaw plugins list
+openclaw plugins inspect openclaw-cortex-memory
+```
+
+If config is not ready, apply the baseline from `configuration.md`.
+
+Exclusive memory mode pre-install check (must be completed before running install commands, including `openclaw plugins install ./openclaw-cortex-memory-0.1.0-Alpha.34.tgz`):
+
+- Before install, do not manually set `plugins.slots.memory` to `openclaw-cortex-memory`.
+- Before install, disable `memory-core` and `memory-lancedb` under `plugins.entries` to avoid mixed backends.
+- After install, the installer may set `plugins.slots.memory` to `openclaw-cortex-memory` automatically; this is expected.
+
+If the user asks for "system prompt rules", use `{baseDir}/references/system-prompt-template.md`.
+
+## Phase 3: Runtime Workflow
+
+### Retrieval-first answers
+
+1. `search_memory` with the user query.
+2. `query_graph` when relationship/path reasoning is needed.
+3. If `query_graph` returns `conflict_hint`, run `list_graph_conflicts` and confirm with user before `resolve_graph_conflict`.
+4. Respond with evidence first, reasoning second.
+
+For retrieval debugging, call `search_memory` with `fusion_mode: "candidates"` to keep ranked candidates alongside fusion output. For benchmarks or diagnostics, set `track_hits: false` so the read does not update anti-decay hit statistics.
+
+Wiki pages are graph projections, not a second memory store. Treat `wiki_ref` / `wiki_refs` from `search_memory` or `query_graph` as display links; use graph/evidence ids as the fact source.
+
+### Persistence
+
+Use `store_event` only for durable information:
+
+- stable preferences
+- project decisions
+- long-lived constraints
+
+Avoid persisting ephemeral chatter.
+
+### Maintenance
+
+- `sync_memory` for historical import
+- `reflect_memory` for rule extraction
+- `backfill_embeddings` for vector repair
+- `export_graph_view` for status-aware graph snapshots
+- `lint_memory_wiki` for projection consistency checks
+- `cortex_diagnostics` (or `diagnostics` alias) when anything looks inconsistent
+
+## Failure Handling
+
+If plugin tools are unavailable:
+
+1. Run `openclaw plugins inspect openclaw-cortex-memory` and `openclaw plugins list`.
+2. If `cortex_diagnostics` is visible, run it for detailed checks.
+3. Explain the issue clearly (plugin disabled, config incomplete, endpoint unavailable, or API key missing).
+4. Provide immediate next action with exact command.
+
+If install or enable flow reports `memory-core` / `memory-lancedb` requirements, keep both disabled in `plugins.entries`.  
+If the host still requests a `memory-lancedb` schema block, add:
+
+```json
+"memory-lancedb": {
+  "enabled": false,
+  "config": {
+    "embedding": {
+      "apiKey": "${MEMORY_LANCEDB_API_KEY}",
+      "model": "text-embedding-3-small"
+    },
+    "dbPath": "~/.openclaw/memory/lancedb",
+    "autoRecall": true,
+    "autoCapture": false,
+    "captureMaxChars": 500
+  }
+}
+```
+
+## Operator Commands Cheat Sheet
+
+```bash
+openclaw plugins install clawhub:openclaw-cortex-memory
+openclaw plugins enable openclaw-cortex-memory
+openclaw plugins inspect openclaw-cortex-memory
+npm pack openclaw-cortex-memory@0.1.0-Alpha.34
+openclaw plugins install ./openclaw-cortex-memory-0.1.0-Alpha.34.tgz
+openclaw plugins enable openclaw-cortex-memory
+rm ./openclaw-cortex-memory-0.1.0-Alpha.34.tgz
+openclaw skills info cortex-memory
+openclaw skills check
+```

package/skills/cortex-memory/references/configuration.md

@@ -0,0 +1,109 @@
+# Configuration Reference
+
+## Minimum OpenClaw Config
+
+Use this as the baseline in `openclaw.json`.
+
+```json
+{
+  "plugins": {
+    "allow": ["openclaw-cortex-memory"],
+    "slots": {
+      "memory": "none"
+    },
+    "entries": {
+      "memory-core": {
+        "enabled": false
+      },
+      "memory-lancedb": {
+        "enabled": false
+      },
+      "openclaw-cortex-memory": {
+        "enabled": true,
+        "config": {
+          "autoSync": true,
+          "autoReflect": false,
+          "graphQualityMode": "warn",
+          "syncPolicy": {
+            "includeLocalActiveInput": false,
+            "graphQualityMode": "strict"
+          },
+          "wikiProjection": {
+            "enabled": true,
+            "mode": "incremental",
+            "maxBatch": 100
+          },
+          "embedding": {
+            "provider": "api",
+            "model": "text-embedding-3-small",
+            "apiKey": "${EMBEDDING_API_KEY}",
+            "baseURL": "https://your-embedding-endpoint/v1",
+            "dimensions": 1536
+          },
+          "llm": {
+            "provider": "api",
+            "model": "gpt-4",
+            "apiKey": "${LLM_API_KEY}",
+            "baseURL": "https://your-llm-endpoint/v1"
+          },
+          "reranker": {
+            "provider": "api",
+            "model": "BAAI/bge-reranker-v2-m3",
+            "apiKey": "${RERANKER_API_KEY}",
+            "baseURL": "https://your-reranker-endpoint/v1/rerank"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Exclusive Mode Rules
+
+- Do not set `plugins.slots.memory` to `openclaw-cortex-memory`.
+- Keep `plugins.entries.memory-core.enabled = false`.
+- Keep `plugins.entries.memory-lancedb.enabled = false`.
+
+## Required Environment Variables
+
+- `EMBEDDING_API_KEY`
+- `LLM_API_KEY`
+- `RERANKER_API_KEY`
+
+## Required Endpoints
+
+- Embedding: OpenAI-compatible `/embeddings`
+- LLM: OpenAI-compatible `/chat/completions`
+- Reranker: `/rerank`
+
+## Troubleshooting: memory backend requirement
+
+If `openclaw plugins install/enable` reports `memory-core` or `memory-lancedb` requirement errors, keep both disabled under `plugins.entries`.  
+If your host still requires a `memory-lancedb` shape check even when disabled, use:
+
+```json
+"memory-lancedb": {
+  "enabled": false,
+  "config": {
+    "embedding": {
+      "apiKey": "${MEMORY_LANCEDB_API_KEY}",
+      "model": "text-embedding-3-small"
+    },
+    "dbPath": "~/.openclaw/memory/lancedb",
+    "autoRecall": true,
+    "autoCapture": false,
+    "captureMaxChars": 500
+  }
+}
+```
+
+## Recommended Validation Commands
+
+```bash
+openclaw plugins list
+openclaw plugins inspect openclaw-cortex-memory
+openclaw skills list
+openclaw skills info cortex-memory
+openclaw skills check
+```

package/skills/cortex-memory/references/publish-checklist.md

@@ -0,0 +1,45 @@
+# ClawHub Publish Checklist
+
+## Preflight
+
+1. Confirm skill root contains `SKILL.md`.
+2. Confirm frontmatter includes:
+   - `name`
+   - `description`
+3. Confirm no secret values are hardcoded in skill files.
+
+## Local Validation
+
+```bash
+openclaw skills list
+openclaw skills info cortex-memory
+openclaw skills check
+```
+
+Optional plugin validation:
+
+```bash
+openclaw plugins list
+openclaw plugins inspect openclaw-cortex-memory
+```
+
+## Publish
+
+```bash
+clawhub login
+clawhub whoami
+clawhub publish ./skills/cortex-memory --slug cortex-memory --name "Cortex Memory" --version 0.1.0 --changelog "Initial ClawHub release" --tags latest
+```
+
+## Install Test (Clean Workspace)
+
+```bash
+openclaw skills install cortex-memory
+openclaw skills info cortex-memory
+```
+
+## Post Publish
+
+1. Start a new session.
+2. Trigger retrieval workflow with a memory-related prompt.
+3. Verify skill appears and is eligible in `openclaw skills list --eligible`.