clawvault 3.4.1 → 3.5.0

package/SKILL.md

@@ -0,0 +1,369 @@
+---
+name: clawvault
+version: "3.5.0"
+description: Agent memory system with memory graph, context profiles, checkpoint/recover, structured storage, semantic search, and observational memory. Use when: storing/searching memories, preventing context death, graph-aware context retrieval, repairing broken sessions. Don't use when: general file I/O.
+author: Versatly
+source: https://github.com/Versatly/clawvault
+repository: https://github.com/Versatly/clawvault
+homepage: https://clawvault.dev
+user-invocable: true
+openclaw: {"emoji":"🐘","requires":{"bins":["clawvault","qmd"],"env":[]},"install":[{"id":"node","kind":"node","package":"clawvault","bins":["clawvault"],"label":"Install ClawVault CLI (npm)"},{"id":"qmd","kind":"node","package":"github:tobi/qmd","bins":["qmd"],"label":"Install qmd backend (required for query/context workflows)"}],"homepage":"https://clawvault.dev"}
+metadata: {"openclaw":{"emoji":"🐘","requires":{"bins":["clawvault","qmd"],"env":[]},"install":[{"id":"node","kind":"node","package":"clawvault","bins":["clawvault"],"label":"Install ClawVault CLI (npm)"},{"id":"qmd","kind":"node","package":"github:tobi/qmd","bins":["qmd"],"label":"Install qmd backend (required for query/context workflows)"}],"homepage":"https://clawvault.dev"}}
+---
+
+# ClawVault 🐘
+
+An elephant never forgets. Structured memory for OpenClaw agents.
+
+> **Built for [OpenClaw](https://openclaw.ai)**. Canonical install: npm CLI + plugin entry registration.
+
+## Security & Transparency
+
+**What this skill does:**
+- Reads/writes markdown files in your vault directory (`CLAWVAULT_PATH` or auto-discovered)
+- `repair-session` reads and modifies OpenClaw session transcripts (`~/.openclaw/agents/`) — creates backups before writing
+- Provides an OpenClaw **plugin entry** (`src/openclaw-plugin.ts` -> `dist/openclaw-plugin.js`) with lifecycle handlers and memory tools.
+- `observe --compress` makes LLM API calls (Gemini Flash by default) to compress session transcripts into observations
+
+**Environment variables used:**
+- `CLAWVAULT_PATH` — vault location (optional, auto-discovered if not set)
+- `OPENCLAW_HOME` / `OPENCLAW_STATE_DIR` — used by `repair-session` to find session transcripts
+- `GEMINI_API_KEY` — used by `observe` for LLM compression (optional, only if using observe features)
+
+**No cloud sync — all data stays local. No network calls except LLM API for observe compression.**
+
+**This is a full CLI tool, not instruction-only.** It writes files, registers plugin handlers/tools, and runs code.
+
+**Auditability:** the published bundle includes `SKILL.md`, `openclaw.plugin.json`, and built plugin runtime in `dist/openclaw-plugin.js`.
+
+## Install (Canonical)
+
+```bash
+npm install -g clawvault
+
+# Add the package path to plugins.load.paths in openclaw.json
+# Enable plugins.entries.clawvault.enabled=true
+# Set plugins.slots.memory="clawvault"
+# Restart gateway process
+```
+
+`clawhub install clawvault` can install skill guidance, but plugin runtime wiring is controlled by OpenClaw plugin config.
+
+### Recommended Safe Install Flow
+
+```bash
+# 1) Review package metadata before install
+npm view clawvault version dist.integrity dist.tarball repository.url
+
+# 2) Install CLI + qmd dependency
+npm install -g clawvault@latest
+npm install -g github:tobi/qmd
+
+# 3) Review plugin manifest and built entrypoint before enabling
+node -e "const fs=require('fs');['openclaw.plugin.json','dist/openclaw-plugin.js'].forEach((p)=>console.log(fs.existsSync(p)?p:`missing: ${p}`))"
+
+# 4) Configure OpenClaw plugin load path + entry, then restart gateway
+```
+
+## Setup
+
+```bash
+# Initialize vault (creates folder structure + templates)
+clawvault init ~/my-vault
+
+# Or set env var to use existing vault
+export CLAWVAULT_PATH=/path/to/memory
+
+# Optional: shell integration (aliases + CLAWVAULT_PATH)
+clawvault shell-init >> ~/.bashrc
+```
+
+## Quick Start for New Agents
+
+```bash
+# Start your session (recover + recap + summary)
+clawvault wake
+
+# Capture and checkpoint during work
+clawvault capture "TODO: Review PR tomorrow"
+clawvault checkpoint --working-on "PR review" --focus "type guards"
+
+# End your session with a handoff
+clawvault sleep "PR review + type guards" --next "respond to CI" --blocked "waiting for CI"
+
+# Health check when something feels off
+clawvault doctor
+```
+
+## Reality Checks Before Use
+
+```bash
+# Verify runtime compatibility with current OpenClaw setup
+clawvault compat
+
+# Verify qmd is available
+qmd --version
+
+# Verify OpenClaw CLI is installed in this shell
+openclaw --version
+```
+
+ClawVault currently depends on `qmd` for core vault/query flows.
+
+## Current Feature Set
+
+### Memory Graph
+
+ClawVault builds a typed knowledge graph from wiki-links, tags, and frontmatter:
+
+```bash
+# View graph summary
+clawvault graph
+
+# Refresh graph index
+clawvault graph --refresh
+```
+
+Graph is stored at `.clawvault/graph-index.json` — schema versioned, incremental rebuild.
+
+### Graph-Aware Context Retrieval
+
+```bash
+# Default context (semantic + graph neighbors)
+clawvault context "database decision"
+
+# With a profile preset
+clawvault context --profile planning "Q1 roadmap"
+clawvault context --profile incident "production outage"
+clawvault context --profile handoff "session end"
+
+# Auto profile (used by OpenClaw plugin)
+clawvault context --profile auto "current task"
+```
+
+### Context Profiles
+
+| Profile | Purpose |
+|---------|---------|
+| `default` | Balanced retrieval |
+| `planning` | Broader strategic context |
+| `incident` | Recent events, blockers, urgent items |
+| `handoff` | Session transition context |
+| `auto` | Plugin-selected profile based on session intent |
+
+### OpenClaw Compatibility Diagnostics
+
+```bash
+# Check plugin wiring and packaging safety
+clawvault compat
+
+# Strict mode for CI
+clawvault compat --strict
+```
+
+## Core Commands
+
+### Wake + Sleep (primary)
+
+```bash
+clawvault wake
+clawvault sleep "what I was working on" --next "ship v1" --blocked "waiting for API key"
+```
+
+### Store memories by type
+
+```bash
+# Types: fact, feeling, decision, lesson, commitment, preference, relationship, project
+clawvault remember decision "Use Postgres over SQLite" --content "Need concurrent writes for multi-agent setup"
+clawvault remember lesson "Context death is survivable" --content "Checkpoint before heavy work"
+clawvault remember relationship "Justin Dukes" --content "Client contact at Hale Pet Door"
+```
+
+### Quick capture to inbox
+
+```bash
+clawvault capture "TODO: Review PR tomorrow"
+```
+
+### Search (requires qmd installed)
+
+```bash
+# Keyword search (fast)
+clawvault search "client contacts"
+
+# Semantic search (slower, more accurate)
+clawvault vsearch "what did we decide about the database"
+```
+
+## Context Death Resilience
+
+### Wake (start of session)
+
+```bash
+clawvault wake
+```
+
+### Sleep (end of session)
+
+```bash
+clawvault sleep "what I was working on" --next "finish docs" --blocked "waiting for review"
+```
+
+### Checkpoint (save state frequently)
+
+```bash
+clawvault checkpoint --working-on "PR review" --focus "type guards" --blocked "waiting for CI"
+```
+
+### Recover (manual check)
+
+```bash
+clawvault recover --clear
+# Shows: death time, last checkpoint, recent handoff
+```
+
+### Handoff (manual session end)
+
+```bash
+clawvault handoff \
+  --working-on "ClawVault improvements" \
+  --blocked "npm token" \
+  --next "publish to npm, create skill" \
+  --feeling "productive"
+```
+
+### Recap (bootstrap new session)
+
+```bash
+clawvault recap
+# Shows: recent handoffs, active projects, pending commitments, lessons
+```
+
+## Auto-linking
+
+Wiki-link entity mentions in markdown files:
+
+```bash
+# Link all files
+clawvault link --all
+
+# Link single file
+clawvault link memory/2024-01-15.md
+```
+
+## Folder Structure
+
+```
+vault/
+├── .clawvault/           # Internal state
+│   ├── last-checkpoint.json
+│   └── dirty-death.flag
+├── decisions/            # Key choices with reasoning
+├── lessons/              # Insights and patterns
+├── people/               # One file per person
+├── projects/             # Active work tracking
+├── handoffs/             # Session continuity
+├── inbox/                # Quick captures
+└── templates/            # Document templates
+```
+
+## Best Practices
+
+1. **Wake at session start** — `clawvault wake` restores context
+2. **Checkpoint every 10-15 min** during heavy work
+3. **Sleep before session end** — `clawvault sleep` captures next steps
+4. **Use types** — knowing WHAT you're storing helps WHERE to put it
+5. **Wiki-link liberally** — `[[person-name]]` builds your knowledge graph
+
+## Checklist for AGENTS.md
+
+```markdown
+## Memory Checklist
+- [ ] Run `clawvault wake` at session start
+- [ ] Checkpoint during heavy work
+- [ ] Capture key decisions/lessons with `clawvault remember`
+- [ ] Use wiki-links like `[[person-name]]`
+- [ ] End with `clawvault sleep "..." --next "..." --blocked "..."`
+- [ ] Run `clawvault doctor` when something feels off
+```
+
+Append this checklist to existing memory instructions. Do not replace your full AGENTS.md behavior unless you intend to.
+
+## Session Transcript Repair (v1.5.0+)
+
+When the Anthropic API rejects with "unexpected tool_use_id found in tool_result blocks", use:
+
+```bash
+# See what's wrong (dry-run)
+clawvault repair-session --dry-run
+
+# Fix it
+clawvault repair-session
+
+# Repair a specific session
+clawvault repair-session --session <id> --agent <agent-id>
+
+# List available sessions
+clawvault repair-session --list
+```
+
+**What it fixes:**
+- Orphaned `tool_result` blocks referencing non-existent `tool_use` IDs
+- Aborted tool calls with partial JSON
+- Broken parent chain references
+
+Backups are created automatically (use `--no-backup` to skip).
+
+## Troubleshooting
+
+- **qmd not installed** — install qmd, then confirm with `qmd --version`
+- **No ClawVault found** — run `clawvault init` or set `CLAWVAULT_PATH`
+- **CLAWVAULT_PATH missing** — run `clawvault shell-init` and add to shell rc
+- **Too many orphan links** — run `clawvault link --orphans`
+- **Inbox backlog warning** — process or archive inbox items
+- **"unexpected tool_use_id" error** — run `clawvault repair-session`
+- **OpenClaw integration drift** — run `clawvault compat`
+- **Plugin not loading** — verify `plugins.load.paths`, `plugins.entries.clawvault.enabled`, and `plugins.slots.memory="clawvault"` in OpenClaw config
+- **Graph out of date** — run `clawvault graph --refresh`
+- **Wrong context for task** — try `clawvault context --profile incident` or `--profile planning`
+
+## Stability Snapshot
+
+- Typecheck passes (`npm run typecheck`)
+- Test suite passes (`449/449`)
+- Cross-platform path handling hardened for Windows in:
+  - qmd URI/document path normalization
+  - WebDAV path safety and filesystem resolution
+  - shell-init output expectations
+- OpenClaw runtime wiring validated by `clawvault compat --strict` (requires local `openclaw` binary for full runtime validation)
+
+## Integration with qmd
+
+ClawVault uses [qmd](https://github.com/tobi/qmd) for search:
+
+```bash
+# Install qmd
+bun install -g github:tobi/qmd
+
+# Alternative
+npm install -g github:tobi/qmd
+
+# Add vault as collection
+qmd collection add /path/to/vault --name my-memory --mask "**/*.md"
+
+# Update index
+qmd update && qmd embed
+```
+
+## Environment Variables
+
+- `CLAWVAULT_PATH` — Default vault path (skips auto-discovery)
+- `OPENCLAW_HOME` — OpenClaw home directory (used by repair-session)
+- `OPENCLAW_STATE_DIR` — OpenClaw state directory (used by repair-session)
+- `GEMINI_API_KEY` — Used by `observe` for LLM-powered compression (optional)
+
+## Links
+
+- npm: https://www.npmjs.com/package/clawvault
+- GitHub: https://github.com/Versatly/clawvault
+- Issues: https://github.com/Versatly/clawvault/issues

package/dist/{chunk-X3SPPUFG.js → chunk-JI7VUQV7.js}

@@ -4,8 +4,18 @@ import * as path from "path";
 import matter from "gray-matter";
 import { spawnSync } from "child_process";
 import { fileURLToPath } from "url";
-var REQUIRED_HOOK_EVENTS = ["gateway:startup", "command:new", "session:start"];
-var REQUIRED_HOOK_BIN = "clawvault";
+var REQUIRED_OPENCLAW_PLUGIN_PATH = "./openclaw.plugin.json";
+var REQUIRED_OPENCLAW_EXTENSION = "./dist/openclaw-plugin.js";
+var LEGACY_HOOK_DIR = "hooks/clawvault";
+var FORBIDDEN_PACKAGE_FILE_ENTRIES = [
+  "hooks",
+  "src",
+  "tests",
+  "testdata",
+  "benchmarks",
+  "eval",
+  "autoresearch"
+];
 function readOptionalFile(filePath) {
   try {
     if (!fs.existsSync(filePath)) return null;
@@ -34,6 +44,17 @@ function resolveProjectFile(relativePath, baseDir) {
   }
   return path.resolve(findPackageRoot(), relativePath);
 }
+function loadPackageJson(options) {
+  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (!packageRaw) {
+    return { parsed: null, error: "package.json not found" };
+  }
+  try {
+    return { parsed: JSON.parse(packageRaw) };
+  } catch (err) {
+    return { parsed: null, error: err?.message || "Unable to parse package.json" };
+  }
+}
 function checkOpenClawCli() {
   const result = spawnSync("openclaw", ["--version"], { stdio: "ignore" });
   if (result.error) {
@@ -41,7 +62,7 @@ function checkOpenClawCli() {
       label: "openclaw CLI available",
       status: "warn",
       detail: "openclaw binary not found",
-      hint: "Install OpenClaw CLI to enable hook runtime validation."
+      hint: "Install OpenClaw CLI to enable runtime validation."
     };
   }
   if (typeof result.status === "number" && result.status !== 0) {
@@ -62,152 +83,69 @@ function checkOpenClawCli() {
   }
   return { label: "openclaw CLI available", status: "ok" };
 }
-function checkPackageHookRegistration(options) {
-  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
-  if (!packageRaw) {
-    return {
-      label: "package hook registration",
-      status: "error",
-      detail: "package.json not found"
-    };
-  }
-  try {
-    const parsed = JSON.parse(packageRaw);
-    const registeredHooks = parsed.openclaw?.hooks ?? [];
-    if (registeredHooks.includes("./hooks/clawvault")) {
-      return {
-        label: "package hook registration",
-        status: "ok",
-        detail: "./hooks/clawvault"
-      };
-    }
-    return {
-      label: "package hook registration",
-      status: "error",
-      detail: "Missing ./hooks/clawvault in package openclaw.hooks"
-    };
-  } catch (err) {
-    return {
-      label: "package hook registration",
-      status: "error",
-      detail: err?.message || "Unable to parse package.json"
-    };
-  }
-}
-function checkHookManifest(options) {
-  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
-  if (!hookRaw) {
-    return {
-      label: "hook manifest",
-      status: "error",
-      detail: "HOOK.md not found"
-    };
-  }
-  try {
-    const parsed = matter(hookRaw);
-    const openclaw = parsed.data?.metadata?.openclaw;
-    const events = Array.isArray(openclaw?.events) ? openclaw?.events ?? [] : [];
-    const missingEvents = REQUIRED_HOOK_EVENTS.filter((event) => !events.includes(event));
-    if (missingEvents.length === 0) {
-      return {
-        label: "hook manifest events",
-        status: "ok",
-        detail: events.join(", ")
-      };
-    }
-    return {
-      label: "hook manifest events",
-      status: "error",
-      detail: `Missing events: ${missingEvents.join(", ")}`
-    };
-  } catch (err) {
-    return {
-      label: "hook manifest events",
-      status: "error",
-      detail: err?.message || "Unable to parse HOOK.md frontmatter"
-    };
-  }
-}
-function checkHookManifestRequirements(options) {
-  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
-  if (!hookRaw) {
+function checkPackagePluginRegistration(options) {
+  const packageJson = loadPackageJson(options);
+  if (!packageJson.parsed) {
     return {
-      label: "hook manifest requirements",
+      label: "package plugin registration",
       status: "error",
-      detail: "HOOK.md not found"
+      detail: packageJson.error
     };
   }
-  try {
-    const parsed = matter(hookRaw);
-    const requiresBins = parsed.data?.metadata?.openclaw?.requires?.bins;
-    const bins = Array.isArray(requiresBins) ? requiresBins : [];
-    if (bins.includes(REQUIRED_HOOK_BIN)) {
-      return {
-        label: "hook manifest requirements",
-        status: "ok",
-        detail: `bins: ${bins.join(", ")}`
-      };
-    }
+  const openclaw = packageJson.parsed.openclaw;
+  const pluginPath = typeof openclaw?.plugin === "string" ? openclaw.plugin : "";
+  if (pluginPath === REQUIRED_OPENCLAW_PLUGIN_PATH) {
     return {
-      label: "hook manifest requirements",
-      status: "warn",
-      detail: `Missing required hook bin "${REQUIRED_HOOK_BIN}"`,
-      hint: 'Add metadata.openclaw.requires.bins: ["clawvault"] to hooks/clawvault/HOOK.md.'
-    };
-  } catch (err) {
-    return {
-      label: "hook manifest requirements",
-      status: "error",
-      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+      label: "package plugin registration",
+      status: "ok",
+      detail: pluginPath
     };
   }
+  return {
+    label: "package plugin registration",
+    status: "error",
+    detail: `Missing openclaw.plugin=${REQUIRED_OPENCLAW_PLUGIN_PATH}`,
+    hint: `Set package.json openclaw.plugin to "${REQUIRED_OPENCLAW_PLUGIN_PATH}".`
+  };
 }
-function checkHookHandlerSafety(options) {
-  const handlerRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/handler.js", options.baseDir));
-  if (!handlerRaw) {
+function checkPackageExtensionRegistration(options) {
+  const packageJson = loadPackageJson(options);
+  if (!packageJson.parsed) {
     return {
-      label: "hook handler script",
+      label: "package extension registration",
       status: "error",
-      detail: "handler.js not found"
+      detail: packageJson.error
     };
   }
-  const usesExecFileSync = handlerRaw.includes("execFileSync");
-  const usesExecSync = /\bexecSync\b/.test(handlerRaw);
-  const enablesShell = /\bshell\s*:\s*true\b/.test(handlerRaw);
-  const delegatesAutoProfile = /['"]--profile['"]\s*,\s*['"]auto['"]/.test(handlerRaw);
-  const violations = [];
-  if (!usesExecFileSync || usesExecSync) {
-    violations.push("execFileSync-only execution path");
-  }
-  if (enablesShell) {
-    violations.push("shell:false execution option");
-  }
-  if (!delegatesAutoProfile) {
-    violations.push("shared context profile delegation (--profile auto)");
-  }
-  if (violations.length > 0) {
+  const openclaw = packageJson.parsed.openclaw;
+  const extensions = Array.isArray(openclaw?.extensions) ? openclaw.extensions : [];
+  if (extensions.includes(REQUIRED_OPENCLAW_EXTENSION)) {
     return {
-      label: "hook handler safety",
-      status: "warn",
-      detail: `Missing conventions: ${violations.join(", ")}`,
-      hint: "Use execFileSync (no shell), avoid execSync, and delegate profile inference via --profile auto."
+      label: "package extension registration",
+      status: "ok",
+      detail: REQUIRED_OPENCLAW_EXTENSION
     };
   }
-  return { label: "hook handler safety", status: "ok" };
+  return {
+    label: "package extension registration",
+    status: "error",
+    detail: `Missing ${REQUIRED_OPENCLAW_EXTENSION} in package openclaw.extensions`,
+    hint: `Add "${REQUIRED_OPENCLAW_EXTENSION}" to package.json openclaw.extensions.`
+  };
 }
 function checkPluginManifest(options) {
-  const manifestRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/openclaw.plugin.json", options.baseDir));
+  const manifestRaw = readOptionalFile(resolveProjectFile("openclaw.plugin.json", options.baseDir));
   if (!manifestRaw) {
     return {
       label: "plugin manifest",
       status: "error",
-      detail: "hooks/clawvault/openclaw.plugin.json not found",
-      hint: "Add openclaw.plugin.json to hooks/clawvault/ for config schema registration."
+      detail: "openclaw.plugin.json not found",
+      hint: "Add root openclaw.plugin.json for OpenClaw plugin config schema."
     };
   }
   try {
     const parsed = JSON.parse(manifestRaw);
-    if (!parsed.id || parsed.id !== "clawvault") {
+    if (parsed.id !== "clawvault") {
       return {
         label: "plugin manifest",
         status: "error",
@@ -218,12 +156,10 @@ function checkPluginManifest(options) {
       return {
         label: "plugin manifest",
         status: "error",
-        detail: "Missing configSchema in plugin manifest",
-        hint: "Add configSchema to openclaw.plugin.json for config validation."
+        detail: "Missing configSchema in plugin manifest"
       };
     }
-    const hasVaultPath = Boolean(parsed.configSchema.properties?.vaultPath);
-    if (!hasVaultPath) {
+    if (!parsed.configSchema.properties?.vaultPath) {
       return {
         label: "plugin manifest",
         status: "warn",
@@ -244,6 +180,56 @@ function checkPluginManifest(options) {
     };
   }
 }
+function checkPackageFilesHygiene(options) {
+  const packageJson = loadPackageJson(options);
+  if (!packageJson.parsed) {
+    return {
+      label: "package files hygiene",
+      status: "error",
+      detail: packageJson.error
+    };
+  }
+  const files = Array.isArray(packageJson.parsed.files) ? packageJson.parsed.files : [];
+  if (files.length === 0) {
+    return {
+      label: "package files hygiene",
+      status: "warn",
+      detail: "package.json files allowlist is missing",
+      hint: "Define package.json files to avoid publishing non-runtime directories."
+    };
+  }
+  const normalized = files.map((entry) => String(entry).replace(/\\/g, "/").replace(/\/+$/, ""));
+  const forbidden = normalized.filter(
+    (entry) => FORBIDDEN_PACKAGE_FILE_ENTRIES.some((name) => entry === name || entry.startsWith(`${name}/`))
+  );
+  if (forbidden.length > 0) {
+    return {
+      label: "package files hygiene",
+      status: "warn",
+      detail: `Forbidden publish entries: ${forbidden.join(", ")}`,
+      hint: "Remove legacy/test/research directories from package.json files."
+    };
+  }
+  return {
+    label: "package files hygiene",
+    status: "ok"
+  };
+}
+function checkLegacyHooksRemoved(options) {
+  const hooksPath = resolveProjectFile(LEGACY_HOOK_DIR, options.baseDir);
+  if (fs.existsSync(hooksPath)) {
+    return {
+      label: "legacy hooks removed",
+      status: "warn",
+      detail: `${LEGACY_HOOK_DIR} still exists`,
+      hint: "Remove hooks/clawvault legacy handler artifacts in plugin-first architecture."
+    };
+  }
+  return {
+    label: "legacy hooks removed",
+    status: "ok"
+  };
+}
 function checkSkillMetadata(options) {
   const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
   if (!skillRaw) {
@@ -284,11 +270,11 @@ function checkSkillMetadata(options) {
 function checkOpenClawCompatibility(options = {}) {
   const checks = [
     checkOpenClawCli(),
-    checkPackageHookRegistration(options),
+    checkPackagePluginRegistration(options),
+    checkPackageExtensionRegistration(options),
     checkPluginManifest(options),
-    checkHookManifest(options),
-    checkHookManifestRequirements(options),
-    checkHookHandlerSafety(options),
+    checkPackageFilesHygiene(options),
+    checkLegacyHooksRemoved(options),
     checkSkillMetadata(options)
   ];
   const warnings = checks.filter((check) => check.status === "warn").length;