@minhpnq1807/contextos 0.6.1 → 0.6.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.6.3
+
+- **Launch benchmark wording:** Clarified that `ctx leaderboard --hallucination` is an offline deterministic benchmark comparing a raw heuristic baseline with ContextOS evidence-based context selection, while live agent results remain pending external CLI environments.
+- **Offline leaderboard labels:** Renamed offline leaderboard output from agent-like labels to `Raw heuristic baseline` and `ContextOS evidence benchmark` so the 10% to 80% result is not confused with a live Codex/Gemini comparison.
+- **Live leaderboard alias:** Added `ctx leaderboard --hallucination --live --agent <name>` as a launch-friendly alias for running the hallucination benchmark through one installed agent CLI. Live benchmark output now reports `OK`/`SKIPPED`/`ERROR` style statuses and supports `CONTEXTOS_<AGENT>_CMD` command templates for external wrappers.
+
+## 0.6.2
+
+- **Live agent leaderboard:** Added `ctx leaderboard --agents codex,gemini` and `npm run leaderboard:agents` to run the hallucination benchmark through installed Codex/Gemini CLIs with timeouts and skip/error reporting for missing or unauthenticated agents.
+- **Live GIF capture:** Added `npm run demo:capture` to regenerate the three launch GIFs from real local `ctx` command output across ContextOS and skill-routing fixture repos.
+- **Community skills sync:** Added `scripts/sync-community-skills.mjs`, `npm run sync:community-skills`, and a scheduled/manual GitHub Action that opens PRs from `khovan123/contextOS-skills` back into `community-skills/`.
+
 ## 0.6.1
 
 - **Hallucination Leaderboard:** Added `ctx leaderboard --hallucination` and `npm run leaderboard:hallucination` to compare raw prompt-only skill guesses against ContextOS evidence-routed skill selection across 20 fixture tasks.

package/README.md

@@ -1,8 +1,8 @@
 # ContextOS
 
-Runtime context router for coding agents.
+Stop coding agents from ignoring repo rules, guessing the wrong path, and reading random files.
 
-Rules, files, skills, workflows, and evidence: injected before the agent writes code.
+ContextOS gives the agent the right rules, files, skills, workflows, and evidence before it writes code.
 
 [![npm version](https://img.shields.io/npm/v/@minhpnq1807/contextos.svg)](https://www.npmjs.com/package/@minhpnq1807/contextos)
 [![CI](https://github.com/khovan123/contextOS/actions/workflows/ci.yml/badge.svg)](https://github.com/khovan123/contextOS/actions/workflows/ci.yml)
@@ -10,19 +10,17 @@ Rules, files, skills, workflows, and evidence: injected before the agent writes
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 ```text
-WITHOUT ContextOS
-  AGENTS.md is a long static blob
-  important rules drift into the middle
-  agent starts by grepping files and misses the repo contract
+Problem: Agents ignore project rules.
+Fix: ContextOS puts the relevant AGENTS.md rules in front of the agent for this task.
 
-WITH ContextOS
-  prompt -> score relevant AGENTS.md rules
-         -> inject critical rules at top and bottom
-         -> suggest files, skills, workflows
-         -> report followed / ignored / unknown
+Problem: Agents choose the wrong deployment path.
+Fix: ContextOS checks repo evidence before suggesting skills like EAS, Vercel, Docker, or CI/CD.
+
+Problem: Agents grep random files.
+Fix: ContextOS suggests the files and workflows to check first.
 ```
 
-ContextOS is not another `AGENTS.md` loader. It is a runtime context router for coding agents: it chooses the task-relevant rules, files, skills, workflows, and evidence before the agent starts editing.
+ContextOS is not another `AGENTS.md` loader. It is a pre-flight context layer for coding agents: it turns repo rules, project signals, skills, workflows, and evidence into a compact task brief before the agent starts editing.
 
 Published package: [`@minhpnq1807/contextos`](https://www.npmjs.com/package/@minhpnq1807/contextos)
 
@@ -36,7 +34,7 @@ Same prompt. Same model. Different context.
 ctx skills doctor -- "fix deployed"
 ```
 
-| Repo evidence | Expected route |
+| Repo evidence | What ContextOS tells the agent |
 | --- | --- |
 | `eas.json`, `expo`, `react-native` | `eas`, `mobile-deployment`, `github-actions-ci-cd` |
 | `vercel.json`, `next`, GitHub workflow | `vercel-deployment`, `github-actions-ci-cd`, `env-secret-management` |
@@ -49,7 +47,13 @@ More 10-second demos:
 | AGENTS.md Lost In The Middle | [docs/demo/agents-lost-middle.gif](docs/demo/agents-lost-middle.gif) |
 | ContextOS Ready Gold | [docs/demo/contextos-ready.gif](docs/demo/contextos-ready.gif) |
 
-## Agent Hallucination Benchmark
+Regenerate the GIFs from real local `ctx` command output:
+
+```bash
+npm run demo:capture
+```
+
+## Wrong Path Benchmark
 
 Generic agents often guess deployment tooling from the prompt alone:
 
@@ -58,7 +62,7 @@ Prompt: Fix deployment
 Raw agent guess: Vercel, Docker, Railway
 ```
 
-ContextOS routes from project evidence instead:
+ContextOS checks the repo first:
 
 ```text
 Detected evidence:
@@ -72,9 +76,9 @@ Selected skills:
 - github-actions-ci-cd
 ```
 
-That is the core launch demo: same prompt, same model, different repo context, correct skills.
+That is the core launch demo: same prompt, same model, different repo, correct next step.
 
-Skill Router internal fixture benchmark:
+Internal fixture benchmark:
 
 | Metric | Result |
 | --- | ---: |
@@ -85,26 +89,44 @@ Skill Router internal fixture benchmark:
 | Confidence Calibration | 100.0% |
 | Negative Gate Accuracy | 100.0% |
 
-This is an internal fixture benchmark, not an external real-world benchmark. It is designed to prove the router behavior across controlled Expo/EAS, Next/Vercel, Docker, Railway/Render, Firebase, auth, database, testing, mobile, and adversarial negative-gate cases.
+This is an internal fixture benchmark, not an external real-world benchmark. It is designed to prove that ContextOS changes its suggestions from repo evidence across controlled Expo/EAS, Next/Vercel, Docker, Railway/Render, Firebase, auth, database, testing, mobile, and adversarial negative cases.
 
-Hallucination leaderboard:
+Offline hallucination leaderboard:
 
 ```bash
 ctx leaderboard --hallucination
 ```
 
-Current local result across 20 fixture tasks and 12 repo contexts:
+Current deterministic result across 20 fixture tasks and 12 repo contexts:
 
-| System | Correct Skill |
+| System | Correct context choice |
 | --- | ---: |
-| Raw Agent | 10.0% |
-| ContextOS + Codex | 80.0% |
+| Raw heuristic baseline | 10.0% |
+| ContextOS evidence benchmark | 80.0% |
+
+This means ContextOS improves deterministic context routing from 10% to 80% on the offline hallucination task set. It does not claim ContextOS beats Codex, Gemini, Claude Code, or Cursor in live runs.
+
+Live agent benchmark support exists, but results are pending an external environment with working CLI auth/session access:
+
+```bash
+ctx leaderboard --hallucination --live --agent codex
+ctx leaderboard --hallucination --live --agent gemini
+```
+
+If a CLI cannot run in the current environment, the command reports `SKIPPED` or an agent error instead of blocking launch.
+
+Live benchmark tracking:
+
+- [Run Codex live benchmark](https://github.com/khovan123/contextOS/issues/1)
+- [Run Claude Code live benchmark](https://github.com/khovan123/contextOS/issues/3)
+- [Run Gemini CLI live benchmark](https://github.com/khovan123/contextOS/issues/4)
+- [Run Cursor live benchmark](https://github.com/khovan123/contextOS/issues/2)
 
 Example hook context injected before the agent works:
 
 ```text
 ## Critical ContextOS rules
-- IMPORTANT: This project has a knowledge graph. ALWAYS use code-review-graph MCP tools before Grep/Glob/Read.
+- IMPORTANT: This project has a knowledge graph. Use it before broad file search.
 - Use `query_graph` pattern="tests_for" to check coverage.
 
 ## Suggested files to check
@@ -123,7 +145,7 @@ ContextOS report
 Efficiency: 100%
 Injected rules: 8
 Rule outcomes: 8 followed, 0 ignored, 0 unknown
-Runtime telemetry: code-review-graph, code-review-graph.query_graph_tool
+Runtime evidence: project graph was used before file search
 ```
 
 ## Quick Install
@@ -166,37 +188,44 @@ ctx install agy
 
 Restart the agent after setup. Then use the agent normally.
 
-## Why
+## Why ContextOS Exists
 
 Developers put real operating instructions in `AGENTS.md`: use this graph tool before reading files, run these tests, follow this architecture boundary, avoid this migration path.
 
-The problem is not that agents cannot read `AGENTS.md`. The problem is that large context windows bury the important rule in the middle, where attention is weak. ContextOS turns a static rules file into task-aware runtime context.
+The problem is not that agents cannot read `AGENTS.md`. The problem is that large context windows bury the important rule in the middle, where attention is weak.
+
+The same thing happens with project structure:
+
+- A deployment prompt says "fix deploy", and the agent guesses Vercel in an Expo repo.
+- A backend error mentions Fastify, and the agent loads frontend skills.
+- A feature request names one route, and the agent starts with broad grep instead of the files that matter.
+
+ContextOS fixes those three failures before the agent starts work.
 
 The next visible demo is not another feature. It is showing the pain in a few seconds:
 
 ```text
 Raw agent: guesses from the prompt.
-ContextOS: routes from repo evidence.
+ContextOS: checks repo evidence first.
 ```
 
 ## What ContextOS Does
 
-| Layer | What happens |
+| Agent failure | ContextOS behavior |
 | --- | --- |
-| Hooks | Codex, Claude Code, and Antigravity hooks run before/after each task. |
-| Scoring | Local MiniLM embeddings plus heuristics rank AGENTS.md rules by the prompt. |
-| Injection | Critical rules are placed with primacy + recency, not buried in the middle. |
-| Discovery | Relevant files, skills, and workflows are suggested before work starts. |
-| Sync | Rules/MCP via Ruler, skills via skillshare, workflows via ContextOS. |
-| Evidence | Stop hooks persist `followed`, `ignored`, `unknown`, and runtime telemetry for explicit reports. |
+| Ignores project rules | Shows the relevant rules at the start of the task. |
+| Picks the wrong tool or deployment path | Suggests skills only when the repo has supporting evidence. |
+| Reads random files first | Suggests the likely files and workflows before exploration starts. |
+| Claims compliance without proof | Reports which rules were followed, ignored, or unknown after the task. |
+| Needs to work across agents | Supports Codex, Claude Code, and Antigravity with the same project context. |
 
 ## Comparison
 
 | Approach | What it gives the agent | Main gap |
 | --- | --- | --- |
 | Plain `AGENTS.md` | Static repo instructions. | Important rules get buried or ignored when the task changes. |
-| Generic RAG | Semantically related files or snippets. | It usually does not route skills/workflows or prove rule compliance. |
-| ContextOS | Task-routed rules, files, skills, workflows, and evidence. | Requires local setup and warm indexes for best results. |
+| Generic RAG | Related files or snippets. | It usually does not choose skills/workflows or prove rule compliance. |
+| ContextOS | Task-specific rules, files, skills, workflows, and evidence. | Requires local setup and prepared indexes for best results. |
 
 ## Safety Model
 
@@ -206,20 +235,20 @@ ContextOS is designed to be OSS-friendly and low-friction:
 | --- | --- |
 | Standalone by default | `ctx setup` works without `code-review-graph`, `codegraph`, or `agent-memory`. |
 | Optional adapters | Graph and memory backends add signal when available; missing adapters contribute score `0`. |
-| Fail-open hooks | Prompt hooks return local context or nothing instead of blocking the agent when MCP, embeddings, graph, or memory is unavailable. |
+| Fail-open hooks | Prompt hooks return local context or nothing instead of blocking the agent when optional runtime pieces are unavailable. |
 | Local-only telemetry | Reports, prompt history, evidence, and telemetry stay under `~/.ctx/contextos/`. |
-| No hook network calls | Prompt and stop hooks do not call external services. Install/warm commands may download the local embedding model when explicitly run. |
+| No hook network calls | Prompt and stop hooks do not call external services. Install/warm commands may prepare local indexes when explicitly run. |
 | No postinstall surprise | `npm install` only installs the CLI. Setup runs only when you call `ctx setup`. |
 
-Positioning: ContextOS works standalone and gets smarter when graph or memory adapters are available.
+Positioning: ContextOS works standalone and gets smarter when project graph or memory adapters are available.
 
 ## Roadmap
 
-ContextOS is not heading toward a dashboard-first product. The next work is focused on making the existing local runtime more visible and reusable:
+ContextOS is not heading toward a dashboard-first product. The next work is focused on making the existing local behavior more visible and reusable:
 
 | Next | Why |
 | --- | --- |
-| Hallucination Leaderboard | Compare raw agent guesses vs ContextOS evidence-routed recommendations across the same repos and tasks. |
+| Hallucination Leaderboard | Compare raw agent guesses vs ContextOS evidence-based recommendations across the same repos and tasks. |
 | Agent Replay | Turn telemetry into a readable post-task narrative: prompt, selected skills, followed rules, suggested files, touched files, efficiency. |
 | Community Skill Packs | Let contributors PR ContextOS-ready skills with triggers, evidence, negative gates, and workflows before building a larger hub. |
 | ContextOS Ready | Define a repository readiness badge for AGENTS.md, skills, workflows, and evidence quality. |
@@ -231,11 +260,11 @@ See [docs/roadmap.md](docs/roadmap.md) for the current roadmap notes.
 
 ContextOS starts the community loop with [`community-skills/`](community-skills/) instead of a hosted marketplace. The seed packs are `eas`, `vercel`, `prisma`, `redis`, `oauth-google`, and `jwt-auth`.
 
-Each pack contains a model-visible `SKILL.md` plus `skill.yaml` routing metadata with prompt triggers, project evidence, negative triggers, and a short workflow. Contributors can PR new packs by copying [`community-skills/_template/`](community-skills/_template/).
+Each pack contains a model-visible `SKILL.md` plus `skill.yaml` metadata with prompt triggers, project evidence, negative triggers, and a short workflow. Contributors can PR new packs by copying [`community-skills/_template/`](community-skills/_template/).
 
 ## ContextOS Ready
 
-`ctx doctor` scores whether a repository is ready for ContextOS-style agent routing:
+`ctx doctor` scores whether a repository is ready for ContextOS-style agent guidance:
 
 ```bash
 ctx doctor
@@ -265,9 +294,11 @@ The score checks project `AGENTS.md` rules, project skill packs under `.codex/sk
 | `ctx evidence` | Show why each rule was marked followed/ignored/unknown. |
 | `ctx stats` | Show workspace-level usage and effectiveness metrics. |
 | `ctx benchmark -- "task"` | Compare raw AGENTS.md ordering vs ContextOS scheduling. |
-| `ctx benchmark --skills` | Run the Skill Router eval benchmark. |
-| `ctx leaderboard --hallucination` | Compare raw prompt-only guesses vs ContextOS routing. |
-| `ctx sync --rules` | Sync AGENTS/Ruler/MCP config across agents. |
+| `ctx benchmark --skills` | Run the skill selection eval benchmark. |
+| `ctx leaderboard --hallucination` | Run the offline deterministic hallucination benchmark. |
+| `ctx leaderboard --hallucination --live --agent codex` | Run the live CLI benchmark when agent auth/session is available. |
+| `ctx leaderboard --agents codex,gemini` | Legacy live CLI leaderboard form. |
+| `ctx sync --rules` | Sync project rules across agents. |
 | `ctx sync --skills` | Sync skills across agents through skillshare. |
 | `ctx sync --workflows` | Sync workflow markdown across Claude/Codex/Antigravity. |
 
@@ -276,7 +307,7 @@ The score checks project `AGENTS.md` rules, project skill packs under `.codex/sk
 1. Start in a repo with an `AGENTS.md` that contains a rule like:
 
 ```text
-Always use code-review-graph MCP tools before reading files.
+Always use the project graph before reading files.
 ```
 
 2. Install:
@@ -591,7 +622,9 @@ This warning comes from a transitive dependency in the local embedding/WASM stac
 | `ctx stats` | Shows aggregate runtime metrics for the current workspace. | You want to know whether ContextOS is active and useful over time. | Prints sectioned tables for prompt/report counts, injection rate, efficiency, rule outcomes, hook events, last prompt, and last report. |
 | `ctx benchmark -- "task"` | Compares baseline AGENTS.md ordering with ContextOS task-aware scheduling. | You want a before/after signal for lost-in-the-middle risk. | Prints tables for parsed/actionable/filtered rules, baseline middle-risk, scheduled high/mid rules, recency reminder status, and top scored rules. |
 | `ctx benchmark --skills` | Runs the Skill Router eval benchmark. | You want evidence for skill routing accuracy and negative gates. | Prints top-1 accuracy, top-3 recall, false positive rate, confidence calibration, and negative gate accuracy across `eval/skill-routing` fixtures. |
-| `ctx leaderboard --hallucination` | Compares raw prompt-only skill guesses with ContextOS evidence routing. | You want launch evidence for the hallucination problem. | Runs 20 fixture tasks across 10+ repo contexts and prints Raw Agent vs ContextOS correctness plus sample failures. |
+| `ctx leaderboard --hallucination` | Runs the offline deterministic hallucination benchmark. | You want launch evidence for the wrong-context problem without depending on external agent auth. | Runs 20 fixture tasks across 10+ repo contexts and prints Raw heuristic baseline vs ContextOS evidence benchmark plus sample failures. |
+| `ctx leaderboard --hallucination --live --agent codex` | Runs the hallucination benchmark through one installed agent CLI. | You want real agent output and have CLI auth/session available. | Calls the selected CLI with timeouts; missing, blocked, or unauthenticated CLIs are reported as skipped/errors instead of blocking. |
+| `ctx leaderboard --agents codex,gemini` | Legacy live CLI leaderboard form. | You want to run multiple live agents at once. | Equivalent live-agent benchmark shape for comma-separated CLIs. |
 | `ctx sync --rules` | Syncs project rules and MCP servers through Ruler. | You want Codex, Claude Code, and Antigravity to share one project rule/MCP source of truth. | Ensures `.ruler/ruler.toml`, injects `ctx-mcp`, imports existing MCP servers from Codex and project `.mcp.json`, runs `ruler apply --agents codex,claude,antigravity`, mirrors MCP servers to Antigravity MCP configs, and verifies generated config. |
 | `ctx sync --rules --agents <list>` | Syncs only selected agents through Ruler. | You want to update one or two agents without touching the others. | Accepts comma-separated values such as `codex`, `claude`, `agy`, `antigravity`, or `codex,claude,agy`; `agy` is normalized to Ruler's `antigravity`. |
 | `ctx sync --rules --dry-run` | Previews Ruler sync without writing files or running apply. | You want to inspect behavior before changing project config. | Prints the same flow with dry-run status. |
@@ -656,7 +689,7 @@ These files are local telemetry only. Hooks do not make network calls.
 
 ## Project Understanding
 
-ContextOS works standalone. The core path is local rules, file embeddings, import graph expansion, skill routing, workflow routing, and evidence capture.
+ContextOS works standalone. The default path is local project rules, prepared file indexes, project skills, workflows, and evidence capture.
 
 Project graph and memory backends are optional adapters:
 
@@ -668,26 +701,24 @@ Project graph and memory backends are optional adapters:
 
 ContextOS does not require `code-review-graph`, `codegraph`, or `agent-memory` to install or run. It gets smarter when those backends are available; when they are missing, the adapter scores stay at zero and the hook continues with local context.
 
-For file suggestions, ContextOS now runs a local RAG-style retrieval pass:
+For file suggestions, ContextOS uses prepared local indexes:
 
 ```text
 prompt
-  -> UserPromptSubmit hook calls ctx-mcp bridge
-  -> ctx-mcp reads AGENTS.md and scores rules with local MiniLM
-  -> query the persisted file-vector index in embeddings.db for semantic file candidates
-  -> expand candidates through relative import graph links
-  -> optionally query code-review-graph semantic_search_nodes with seed entity names
-  -> merge and deduplicate semantic, import-graph, and optional graph matches
-  -> inject top suggested files with graph evidence reasons
+  -> read task-relevant AGENTS.md rules
+  -> suggest prepared file candidates
+  -> expand nearby imports
+  -> add optional project-graph matches when available
+  -> inject a compact list of files to check
 ```
 
-This keeps the hook fast and local while still using graph semantics when available. The graph search path is visible in runtime data through file reasons such as `graph:content-moderation.service`. When no graph adapter is available, file suggestions still use local file vectors and import graph expansion.
+This keeps the hook fast and local while still using project graph signal when available. When no graph adapter is available, file suggestions still use local file indexes and import expansion.
 
-Prompt scoring does not walk the repository for file candidates or import expansion. `ctx install` and `ctx embeddings warm` rebuild the persisted file-vector index and one-hop import adjacency index by walking source paths once; prompt hooks query those indexes directly. Rules, files, skills, and workflows are scored concurrently with `Promise.all()`.
+Prompt-time file suggestions do not walk the repository. `ctx install` and `ctx embeddings warm` rebuild the file index and one-hop import adjacency by walking source paths once; prompt hooks query those prepared indexes directly. Rules, files, skills, and workflows are resolved concurrently.
 
 `ctx embeddings warm` automatically refreshes the active Codex marketplace payload before rebuilding indexes. Use `ctx refresh` when you want the same marketplace sync plus install-style file, skill, import, and code-review-graph embedding refresh in one command.
 
-If a prompt has no usable context candidates, the hook fails open without emitting an empty `hook context` block, records `emptyContextReason` in the workspace runtime file, and starts a detached `autowarm` rebuild with a cooldown. That background rebuild refreshes file vectors, skill/workflow vectors, import adjacency, and available code-review-graph node embeddings for the next prompt while keeping repository walking out of the current prompt hot path.
+If a prompt has no usable context candidates, the hook fails open without emitting an empty `hook context` block, records `emptyContextReason` in the workspace runtime file, and starts a detached `autowarm` rebuild with a cooldown. That background rebuild refreshes prepared indexes for the next prompt while keeping repository walking out of the current prompt path.
 
 Use `ctx --config` to choose which prompt sections ContextOS injects and how many suggestions each section may show. Interactive `ctx setup` includes the same section picker and limit prompts, while `ctx setup --yes` keeps the current saved config for automation. The panel supports multiple selection with `Space` and persists the global choice in `~/.ctx/contextos/output-config.json`. Defaults are five suggested files, five skills, and five workflows; caps are 20 files, 10 skills, and 5 workflows. Disabling rules hides both critical and additional relevant rule sections; compliance metadata remains available for reports.
 

package/bin/ctx.js

@@ -21,6 +21,7 @@ import { installMcpTelemetryProxies } from "../plugins/ctx/lib/mcp-proxy-install
 import { benchmarkWorkspace, formatBenchmark } from "../plugins/ctx/lib/benchmark.js";
 import { formatSkillRoutingBenchmark, runSkillRoutingEval } from "../eval/skill-routing/run-eval.js";
 import { formatHallucinationLeaderboard, runHallucinationLeaderboard } from "../eval/hallucination/run-leaderboard.js";
+import { formatAgentLeaderboard, runAgentLeaderboard } from "../eval/hallucination/run-agent-leaderboard.js";
 import { copyDir, copyPackageRoot, syncPackageRoot } from "../plugins/ctx/lib/package-install.js";
 import { installClaudeHooks } from "../plugins/ctx/lib/claude-hooks.js";
 import { installClaudeMcp } from "../plugins/ctx/lib/claude-mcp.js";
@@ -198,7 +199,10 @@ Usage:
   ctx stats                                         Show workspace statistics
   ctx benchmark -- "task"                           Benchmark workspace for a task
   ctx benchmark --skills                            Run skill routing eval benchmark
-  ctx leaderboard --hallucination                   Compare raw agent guesses vs ContextOS routing
+  ctx leaderboard --hallucination                   Run offline deterministic hallucination benchmark
+  ctx leaderboard --hallucination --live --agent codex
+                                                    Run hallucination benchmark through one live CLI
+  ctx leaderboard --agents codex,gemini             Run live CLI leaderboard for installed agents
   ctx sync --rules                                  Sync AGENTS.md rules to all agents
   ctx sync --rules --agents <names>                 Sync rules to specific agents only
   ctx sync --rules --dry-run                        Preview rule sync without writing
@@ -250,6 +254,18 @@ function normalizeInstallAgent(agent) {
   if (normalized === "antigravity") return "agy";
   return normalized;
 }
+
+function leaderboardAgentsFromArgs(args) {
+  const agentIndex = args.indexOf("--agent");
+  const agentsIndex = args.indexOf("--agents");
+  const index = agentIndex >= 0 ? agentIndex : agentsIndex;
+  if (index < 0) return [];
+  return String(args[index + 1] || "")
+    .split(",")
+    .map((agent) => agent.trim())
+    .filter(Boolean);
+}
+
 /**
  * Intercept console.log from an async fn,
  * printing each line immediately with "│  " prefix for real-time feedback.
@@ -1037,10 +1053,31 @@ try {
     console.log(formatBenchmark(benchmarkWorkspace({ cwd: process.cwd(), task })));
     }
   } else if (command === "leaderboard") {
-    if (args.includes("--hallucination")) {
+    if (args.includes("--hallucination") && args.includes("--live")) {
+      const agents = leaderboardAgentsFromArgs(args);
+      const limitIndex = args.indexOf("--limit");
+      const timeoutIndex = args.indexOf("--timeout-ms");
+      console.log(formatAgentLeaderboard(runAgentLeaderboard({
+        rootDir,
+        agents: agents.length ? agents : undefined,
+        caseLimit: limitIndex >= 0 ? Number(args[limitIndex + 1]) : undefined,
+        timeoutMs: timeoutIndex >= 0 ? Number(args[timeoutIndex + 1]) : undefined
+      })));
+    } else if (args.includes("--hallucination")) {
       console.log(formatHallucinationLeaderboard(await runHallucinationLeaderboard({ rootDir })));
+    } else if (args.includes("--agents")) {
+      const index = args.indexOf("--agents");
+      const agents = String(args[index + 1] || "").split(",").map((agent) => agent.trim()).filter(Boolean);
+      const limitIndex = args.indexOf("--limit");
+      const timeoutIndex = args.indexOf("--timeout-ms");
+      console.log(formatAgentLeaderboard(runAgentLeaderboard({
+        rootDir,
+        agents: agents.length ? agents : undefined,
+        caseLimit: limitIndex >= 0 ? Number(args[limitIndex + 1]) : undefined,
+        timeoutMs: timeoutIndex >= 0 ? Number(args[timeoutIndex + 1]) : undefined
+      })));
     } else {
-      throw new Error("Usage: ctx leaderboard --hallucination");
+      throw new Error("Usage: ctx leaderboard --hallucination OR ctx leaderboard --hallucination --live --agent codex OR ctx leaderboard --agents codex,gemini");
     }
   } else if (command === "skills") {
     if (args[1] === "doctor") {

package/docs/demo/agents-lost-middle.txt

@@ -1,28 +1,25 @@
-$ cat AGENTS.md
-1. General style
-2. Formatting
-3. Test names
-...
-37. IMPORTANT: Always use code-review-graph before grep.
-...
-52. Release notes
+$ ctx benchmark -- "fix failing test"
+ContextOS benchmark
 
-$ codex "fix failing test"
-Raw agent starts with grep
-Rule followed: no
+Summary
+-------
+Metric                Value
+--------------------  -------------------------
+Task                  fix failing test
+Rules parsed          7
+Actionable rules      5
+Filtered rules        2
+Relevant rules        1
+Baseline middle-risk  1/1 relevant rules (100%)
+ContextOS scheduled   1 high, 0 mid
+Recency reminder      enabled
 
-$ ctx debug -- "fix failing test"
-ContextOS debug
-Critical ContextOS rules:
-- IMPORTANT: Always use code-review-graph before grep.
-
-Suggested files to check:
-- test/score-context.test.js
-- plugins/ctx/lib/score-context.js
-
-$ codex + ContextOS
-Rule followed: yes
-Evidence: graph checked before file reads
-
-AGENTS.md did not change.
-The rule moved from buried context into runtime context.
+Top Rules
+---------
+Score  Rule                                                                                      Reasons
+-----  ----------------------------------------------------------------------------------------  ----------
+0.50   IMPORTANT: This project has a knowledge graph. ALWAYS use code-review-graph MCP tools...  imperative
+0.00   AGENTS.md
+0.00   Centralised AI agent instructions. Add coding guidelines, style guides, and project c...
+0.00   Ruler concatenates all .md files in this directory (and subdirectories), starting wit...
+0.00   Use `query_graph` pattern="tests_for" to check coverage.

package/docs/demo/capture-live-demos.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { benchmarkWorkspace, formatBenchmark } from "../../plugins/ctx/lib/benchmark.js";
+import { formatContextOSReady, inspectContextOSReady } from "../../plugins/ctx/lib/certification.js";
+import { formatHallucinationLeaderboard, runHallucinationLeaderboard } from "../../eval/hallucination/run-leaderboard.js";
+import { runSkillRoutingEval } from "../../eval/skill-routing/run-eval.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..", "..");
+const render = path.join(__dirname, "render-terminal-gif.mjs");
+const leaderboard = await runHallucinationLeaderboard({ rootDir: repoRoot });
+const skillEval = await runSkillRoutingEval({ rootDir: repoRoot });
+
+const demos = [
+  {
+    log: "same-prompt-different-context.txt",
+    gif: "same-prompt-different-context.gif",
+    steps: [
+      ["ctx leaderboard --hallucination", formatHallucinationLeaderboard(leaderboard)],
+      ["ctx skills doctor -- \"fix deployed\"  # Expo fixture", routeSummary("expo-eas", "fix deployed")],
+      ["ctx skills doctor -- \"fix deployed\"  # Next/Vercel fixture", routeSummary("next-vercel", "fix deployed")]
+    ]
+  },
+  {
+    log: "agents-lost-middle.txt",
+    gif: "agents-lost-middle.gif",
+    steps: [
+      ["ctx benchmark -- \"fix failing test\"", formatBenchmark(benchmarkWorkspace({ cwd: repoRoot, task: "fix failing test" }))]
+    ]
+  },
+  {
+    log: "contextos-ready.txt",
+    gif: "contextos-ready.gif",
+    steps: [
+      ["ctx doctor", formatContextOSReady(inspectContextOSReady({ cwd: repoRoot }))]
+    ]
+  }
+];
+
+for (const demo of demos) {
+  const logPath = path.join(__dirname, demo.log);
+  const gifPath = path.join(__dirname, demo.gif);
+  const chunks = [];
+  for (const [label, output] of demo.steps) {
+    chunks.push(`$ ${label}`);
+    chunks.push(cleanOutput(output));
+    chunks.push("");
+  }
+  fs.writeFileSync(logPath, chunks.join("\n").trimEnd() + "\n", "utf8");
+  execFileSync(process.execPath, [render, logPath, gifPath], { cwd: repoRoot, stdio: "inherit" });
+}
+
+function cleanOutput(output) {
+  return String(output || "")
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .trim();
+}
+
+function routeSummary(fixture, prompt) {
+  const row = skillEval.rows.find((item) => item.fixture === fixture && item.prompt === prompt);
+  if (!row) return "No route found.";
+  return [
+    "ContextOS skill doctor",
+    `fixture: ${fixture}`,
+    `prompt: ${prompt}`,
+    `selected: ${row.selectedIds.join(", ") || "(none)"}`,
+    `expected: ${row.expected.join(", ") || "(none)"}`,
+    `rejected: ${row.forbidden.join(", ") || "(none)"}`
+  ].join("\n");
+}

package/docs/demo/contextos-ready.txt

@@ -12,9 +12,3 @@ Evidence:
 - Rules: 1 AGENTS.md source(s), 5 actionable rule(s)
 - Skills: 3 skill(s), 3 metadata file(s)
 - Workflows: 2 workflow(s), 2 with agent chain(s)
-
-$ badge
-[ContextOS Ready Gold]
-
-Repos now have a target:
-AGENTS.md + skills + workflows + evidence.

package/docs/demo/render-terminal-gif.mjs

@@ -35,7 +35,7 @@ for (let count = 1; count <= displayLines.length; count += frameStep) {
 frames.push(writeFrame({ tmpDir, index: frames.length, lines: displayLines }));
 
 fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-execFileSync("convert", ["-delay", "12", "-loop", "0", ...frames, outputPath], { stdio: "inherit" });
+execFileSync("convert", ["-limit", "time", "120", "-delay", "12", "-loop", "0", ...frames, outputPath], { stdio: "inherit" });
 console.log(`Wrote ${outputPath}`);
 
 function writeFrame({ tmpDir, index, lines }) {

package/docs/demo/same-prompt-different-context.txt

@@ -8,19 +8,44 @@ System              Correct Skill
 Raw Agent           10.0%
 ContextOS + Codex   80.0%
 
-$ ctx skills doctor -- "fix deployed"  # Expo repo
-ContextOS skill doctor
-1. eas high confidence
-   evidence: eas.json, app.json, expo dependency
-2. mobile-deployment high confidence
-3. github-actions-ci-cd medium confidence
+Sample failures:
+- expo-eas: "fix deployed"
+  expected: eas, mobile-deployment, github-actions-ci-cd
+  raw: eas, env-secret-management, railway-render-deployment ✗
+  contextos: eas, github-actions-ci-cd, mobile-deployment ✓
+- next-vercel: "fix deployed"
+  expected: vercel-deployment, github-actions-ci-cd, env-secret-management
+  raw: eas, env-secret-management, railway-render-deployment ✗
+  contextos: vercel-deployment, github-actions-ci-cd, env-secret-management ✓
+- docker-node: "docker image build failed"
+  expected: docker, build-log-debugging
+  raw: docker, build-log-debugging, github-actions-ci-cd ✗
+  contextos: build-log-debugging, docker ✓
+- railway-render: "Railway deploy health check failed"
+  expected: railway-render-deployment, build-log-debugging
+  raw: railway-render-deployment, build-log-debugging, firebase-hosting ✗
+  contextos: build-log-debugging, railway-render-deployment ✓
+- firebase-hosting: "deploy firebase hosting"
+  expected: firebase-hosting
+  raw: firebase-hosting, flutter-firebase, railway-render-deployment ✗
+  contextos: firebase-hosting ✓
+- nest-prisma: "optimize slow prisma queries"
+  expected: prisma, nestjs-module
+  raw: prisma, nestjs-module, android-signing ✗
+  contextos: nestjs-module, prisma ✓
 
-$ ctx skills doctor -- "fix deployed"  # Next.js repo
+$ ctx skills doctor -- "fix deployed"  # Expo fixture
 ContextOS skill doctor
-1. vercel-deployment high confidence
-   evidence: vercel.json, next dependency
-2. github-actions-ci-cd high confidence
-3. env-secret-management medium confidence
+fixture: expo-eas
+prompt: fix deployed
+selected: eas, github-actions-ci-cd, mobile-deployment
+expected: eas, mobile-deployment, github-actions-ci-cd
+rejected: vercel-deployment
 
-Same prompt. Same model. Different repo evidence.
-ContextOS routes the right skill before the agent edits code.
+$ ctx skills doctor -- "fix deployed"  # Next/Vercel fixture
+ContextOS skill doctor
+fixture: next-vercel
+prompt: fix deployed
+selected: vercel-deployment, github-actions-ci-cd, env-secret-management
+expected: vercel-deployment, github-actions-ci-cd, env-secret-management
+rejected: eas

package/eval/hallucination/run-agent-leaderboard.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { parseEvalYaml } from "../skill-routing/run-eval.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..", "..");
+const skillEvalRoot = path.resolve(__dirname, "..", "skill-routing");
+const DEFAULT_AGENTS = ["codex", "gemini"];
+const DEFAULT_CASE_LIMIT = 5;
+const DEFAULT_TIMEOUT_MS = 120000;
+
+export function runAgentLeaderboard({
+  agents = DEFAULT_AGENTS,
+  casesPath = path.join(skillEvalRoot, "cases.yaml"),
+  caseLimit = DEFAULT_CASE_LIMIT,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  rootDir = repoRoot
+} = {}) {
+  const config = parseEvalYaml(fs.readFileSync(casesPath, "utf8"));
+  const cases = config.cases
+    .filter((row) => row.expected?.length)
+    .slice(0, caseLimit);
+  const skillIds = config.skills.map((skill) => skill.id);
+  const systems = [];
+
+  for (const agent of agents) {
+    const template = agentCommandTemplate(agent);
+    const binary = template ? template.split(/\s+/).filter(Boolean)[0] : findBinary(agent);
+    if (!binary) {
+      systems.push({ name: agent, status: "skipped", reason: "binary not found", rows: [], correctRate: 0 });
+      continue;
+    }
+    const rows = cases.map((testCase) => runAgentCase({
+      agent,
+      binary,
+      testCase,
+      skillIds,
+      timeoutMs,
+      rootDir
+    }));
+    const completed = rows.filter((row) => row.status === "ok");
+    const correct = completed.filter((row) => row.correct).length;
+    systems.push({
+      name: agent,
+      status: completed.length ? "ok" : "skipped",
+      reason: completed.length ? "" : firstReason(rows),
+      rows,
+      correctRate: completed.length ? correct / completed.length : 0
+    });
+  }
+
+  return {
+    mode: "live-agent-cli",
+    caseCount: cases.length,
+    systems
+  };
+}
+
+export function formatAgentLeaderboard(result) {
+  const lines = [
+    "Live Agent Leaderboard",
+    `Mode: ${result.mode}`,
+    `Tasks: ${result.caseCount}`,
+    "",
+    "System    Status    Correct Skill",
+    "--------  --------  -------------"
+  ];
+  for (const system of result.systems) {
+    const score = system.status === "ok" ? percent(system.correctRate) : system.reason;
+    lines.push(`${system.name.padEnd(8)}  ${system.status.toUpperCase().padEnd(8)}  ${score}`);
+  }
+  lines.push("", "Cases:");
+  for (const system of result.systems) {
+    lines.push(`- ${system.name}`);
+    for (const row of system.rows.slice(0, 5)) {
+      lines.push(`  - ${row.fixture}: "${row.prompt}"`);
+      lines.push(`    selected: ${row.selectedIds.join(", ") || "(none)"} ${row.correct ? "✓" : "✗"}`);
+      if (row.status !== "ok") lines.push(`    status: ${row.status}; ${row.reason}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function runAgentCase({ agent, binary, testCase, skillIds, timeoutMs, rootDir }) {
+  const cwd = testCase.fixture === "contextos"
+    ? rootDir
+    : path.join(skillEvalRoot, "fixtures", testCase.fixture);
+  const prompt = buildPrompt({ task: testCase.prompt, skillIds });
+  const startedAt = Date.now();
+  const result = spawnSync(binary, agentArgs({ agent, cwd, prompt }), {
+    cwd,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    maxBuffer: 1024 * 1024 * 4,
+    env: {
+      ...process.env,
+      NO_COLOR: "1",
+      CI: process.env.CI || "1"
+    }
+  });
+  const output = `${result.stdout || ""}\n${result.stderr || ""}`.trim();
+  const selectedIds = parseSkillIds(output, skillIds).slice(0, 3);
+  const correct = isCorrect({
+    selectedIds,
+    expected: testCase.expected || [],
+    allowed: testCase.allowed || [],
+    forbidden: testCase.forbidden || []
+  });
+  return {
+    status: result.error ? "error" : result.status === 0 ? "ok" : "error",
+    reason: result.error?.message || (result.status === 0 ? "" : `exit ${result.status}`),
+    prompt: testCase.prompt,
+    fixture: testCase.fixture,
+    expected: testCase.expected || [],
+    selectedIds,
+    correct,
+    durationMs: Date.now() - startedAt
+  };
+}
+
+function agentArgs({ agent, cwd, prompt }) {
+  const genericTemplate = agentCommandTemplate(agent);
+  if (genericTemplate) return expandTemplate(genericTemplate, { cwd, prompt }).slice(1);
+  if (agent === "codex") {
+    return [
+      "exec",
+      "--cd", cwd,
+      "--sandbox", "read-only",
+      "--ask-for-approval", "never",
+      prompt
+    ];
+  }
+  if (agent === "gemini") {
+    const template = process.env.CONTEXTOS_GEMINI_CMD;
+    if (template) return expandTemplate(template, { cwd, prompt });
+    return ["-p", prompt];
+  }
+  return [prompt];
+}
+
+function agentCommandTemplate(agent) {
+  const envKey = `CONTEXTOS_${String(agent || "").toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_CMD`;
+  return process.env[envKey] || "";
+}
+
+function buildPrompt({ task, skillIds }) {
+  return [
+    "You are evaluating a repository for a coding-agent skill router benchmark.",
+    "Do not edit files. Do not run commands.",
+    `Task: ${task}`,
+    `Allowed skill IDs: ${skillIds.join(", ")}`,
+    "Return only the top skill IDs as comma-separated text. No explanations."
+  ].join("\n");
+}
+
+function parseSkillIds(output, skillIds) {
+  const normalized = new Map(skillIds.map((id) => [normalize(id), id]));
+  const found = [];
+  for (const token of String(output || "").split(/[^A-Za-z0-9_.@-]+/)) {
+    const id = normalized.get(normalize(token));
+    if (id && !found.includes(id)) found.push(id);
+  }
+  return found;
+}
+
+function isCorrect({ selectedIds, expected, allowed, forbidden }) {
+  const selected = new Set(selectedIds);
+  const accepted = new Set([...expected, ...allowed]);
+  return expected.every((skill) => selected.has(skill))
+    && forbidden.every((skill) => !selected.has(skill))
+    && selectedIds.every((skill) => accepted.has(skill));
+}
+
+function findBinary(name) {
+  const safeName = shellQuote(name);
+  const candidates = [
+    path.join(os.homedir(), ".local", "bin", safeName),
+    path.join(os.homedir(), ".npm-global", "bin", safeName),
+    path.join(os.homedir(), ".nvm", "current", "bin", safeName),
+    `/mnt/c/Users/admin/AppData/Roaming/npm/${safeName}`,
+    `/mnt/c/Users/admin/AppData/Roaming/npm/${safeName}.cmd`
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const dir of String(process.env.PATH || "").split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, safeName);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const command of [
+    `command -v ${safeName}`,
+    `source ~/.profile >/dev/null 2>&1 || true; source ~/.bashrc >/dev/null 2>&1 || true; command -v ${safeName}`
+  ]) {
+    try {
+      const found = execFileSync("bash", ["-lc", command], { encoding: "utf8" }).trim();
+      if (found) return found;
+    } catch {
+      // continue
+    }
+  }
+  return "";
+}
+
+function firstReason(rows) {
+  return rows.find((row) => row.reason)?.reason || "no completed cases";
+}
+
+function normalize(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+function shellQuote(value) {
+  return String(value).replace(/[^A-Za-z0-9_./-]/g, "");
+}
+
+function expandTemplate(template, vars) {
+  const file = path.join(os.tmpdir(), `contextos-agent-prompt-${process.pid}-${Date.now()}.txt`);
+  fs.writeFileSync(file, vars.prompt, "utf8");
+  return String(template)
+    .replaceAll("{cwd}", vars.cwd)
+    .replaceAll("{prompt_file}", file)
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function percent(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const agentsArg = process.argv.find((arg) => arg.startsWith("--agents="));
+  const limitArg = process.argv.find((arg) => arg.startsWith("--limit="));
+  const timeoutArg = process.argv.find((arg) => arg.startsWith("--timeout-ms="));
+  const result = runAgentLeaderboard({
+    agents: agentsArg ? agentsArg.slice("--agents=".length).split(",").map((item) => item.trim()).filter(Boolean) : DEFAULT_AGENTS,
+    caseLimit: limitArg ? Number(limitArg.slice("--limit=".length)) : DEFAULT_CASE_LIMIT,
+    timeoutMs: timeoutArg ? Number(timeoutArg.slice("--timeout-ms=".length)) : DEFAULT_TIMEOUT_MS
+  });
+  console.log(formatAgentLeaderboard(result));
+}

package/eval/hallucination/run-leaderboard.js

@@ -41,8 +41,8 @@ export async function runHallucinationLeaderboard({
     caseCount: selectedCases.length,
     repoCount: new Set(selectedCases.map((row) => row.fixture)).size,
     systems: [
-      summarizeSystem("Raw Agent", rawRows),
-      summarizeSystem("ContextOS + Codex", contextRows)
+      summarizeSystem("Raw heuristic baseline", rawRows),
+      summarizeSystem("ContextOS evidence benchmark", contextRows)
     ],
     rows: selectedCases.map((testCase) => ({
       prompt: testCase.prompt,
@@ -60,11 +60,11 @@ export function formatHallucinationLeaderboard(result) {
     `Repos: ${result.repoCount}`,
     `Tasks: ${result.caseCount}`,
     "",
-    "System              Correct Skill",
-    "------------------  -------------"
+    "System                        Correct Context",
+    "----------------------------  ---------------"
   ];
   for (const system of result.systems) {
-    lines.push(`${system.name.padEnd(18)}  ${percent(system.correctRate)}`);
+    lines.push(`${system.name.padEnd(28)}  ${percent(system.correctRate)}`);
   }
   lines.push("", "Sample failures:");
   const failures = result.rows

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhpnq1807/contextos",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Task-aware AGENTS.md context injection and compliance reporting for Codex, Claude Code, and Antigravity.",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
   "files": [
     "bin/",
     "plugins/",
+    "scripts/",
     ".codex/skills/",
     ".codex/workflows/",
     ".agents/",
@@ -28,6 +29,9 @@
     "validate:plugin": "node test/validate-plugin.js",
     "benchmark:skills": "node bin/ctx.js benchmark --skills",
     "leaderboard:hallucination": "node eval/hallucination/run-leaderboard.js",
+    "leaderboard:agents": "node eval/hallucination/run-agent-leaderboard.js --agents=codex,gemini",
+    "demo:capture": "node docs/demo/capture-live-demos.mjs",
+    "sync:community-skills": "node scripts/sync-community-skills.mjs",
     "test:mcp": "node test/mcp-protocol-smoke.js"
   },
   "engines": {

package/plugins/ctx/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Inject task-relevant AGENTS.md rules into Codex through plugin hooks.",
   "author": {
     "name": "ContextOS"

package/scripts/sync-community-skills.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+
+const [, , sourceArg = "external-skills", targetArg = "community-skills"] = process.argv;
+const source = path.resolve(sourceArg);
+const target = path.resolve(targetArg);
+const skip = new Set([".git", ".github", "scripts"]);
+
+if (!fs.existsSync(source)) {
+  console.error(`Missing source skills directory: ${source}`);
+  process.exit(1);
+}
+
+fs.mkdirSync(target, { recursive: true });
+
+for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+  if (entry.isDirectory()) fs.rmSync(path.join(target, entry.name), { recursive: true, force: true });
+  else if (entry.isFile() && entry.name !== "README.md") fs.rmSync(path.join(target, entry.name), { force: true });
+}
+
+for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+  if (skip.has(entry.name)) continue;
+  const from = path.join(source, entry.name);
+  const to = path.join(target, entry.name);
+  if (entry.isDirectory()) copyDir(from, to);
+  else if (entry.isFile() && entry.name === "README.md") fs.copyFileSync(from, to);
+}
+
+console.log(`Synced ContextOS skills from ${source} to ${target}`);
+
+function copyDir(from, to) {
+  fs.mkdirSync(to, { recursive: true });
+  for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+    const sourcePath = path.join(from, entry.name);
+    const targetPath = path.join(to, entry.name);
+    if (entry.isDirectory()) copyDir(sourcePath, targetPath);
+    else if (entry.isFile()) fs.copyFileSync(sourcePath, targetPath);
+  }
+}