OpenSite AI技能库

Prerequisites

1. Node.js 18+ — for Playwright
2. Brave Browser — must be installed at /Applications/Brave Browser.app
3. Session cookies — one per cloud platform (see below)

Quick Setup

For local platforms: Claude Code, Codex, Cursor, Factory/Droid, GitHub Copilot, Mistral Vibe, and OpenCode. Dedicated scripts for cloud platforms (Perplexity, Claude Desktop) below.

```bash

2. Run the setup script

./setup.sh ```

The setup script detects which platforms are installed and creates symlinks from each platform's skills directory to this repo — no file copying. This includes Mistral Vibe, which will automatically sync the skills from this repo.

Permission denied running `./setup.sh`?

If you see bash: ./setup.sh: Permission denied (or zsh: permission denied: ./setup.sh), the script isn't marked executable on your machine. Fix it with:

chmod +x setup.sh
./setup.sh

This flips the executable bit on the file so your shell is allowed to run it directly. You only need to do this once per clone. Alternatively, you can skip chmod entirely and just run it through bash:

bash setup.sh

---

In your skills directory -- install this skill via setup.sh

Just run setup.sh -- the skill is ready

./setup.sh ```

Cursor, Windsurf, Cline, Copilot users

This skill works on all of these platforms. None of them have hook support, so the skill's explicit-invocation pattern is the only option for context virtualization. Run setup.sh and the SKILL.md routing rules take effect.

log:fly-deploy 2x saved 2.8 KB (18% ratio)

Manual Setup

Quick Start

```bash

Usage Examples

Claude Code / Codex — starting a refactor with the spec gate:

@large-scale-refactor js-to-ts-migration

Convert all .js files in src/components/ to TypeScript.
No logic changes. No style changes. Only type annotations
and updating import extensions. Approximately 180 files.

The agent writes the full spec and outputs:

⏸ SPEC GATE: Please review and reply 'approved' to begin execution,
or provide corrections.

No file is touched until you respond.

Claude Desktop — automatic activation from natural language:

"Migrate all our API route handlers from Express callbacks to
async/await. There are about 90 route files in src/routes/."

The skill loads automatically and begins with the spec gate.

Parallel agents — Factory Droid or Devin playbooks:

```

In config.toml -- keep the MCP server

[mcp-servers.context-mode] command = "npx" args = ["context-mode", "--mcp"]

Optional: symlink CLAUDE.md

ln -sfn ~/opensite-skills/CLAUDE.md ~/.claude/CLAUDE.md ```

Standard Session Workflow

┌─────────────────────────────────────────────────────────────┐
│  SESSION START                                              │
│  /memory-recall   ← loads working memory + relevant context │
│                                                             │
│  [... do your work ...]                                     │
│                                                             │
│  SESSION END                                                │
│  /memory-write    ← captures decisions, facts, next steps   │
└─────────────────────────────────────────────────────────────┘

Weekly / Monthly:
  /memory-consolidate  ← decays stale entries, deduplicates, compresses

What memory-recall loads

1. store/working/active.md — always first; the hot state from last session
2. Semantic memories relevant to the current project and technology keywords
3. Architecture Decision Records (ADRs) for the active project
4. Code conventions and workflows for the active project
5. The 3 most recent episodic session summaries

What memory-write saves

• Episodic — a session summary (goal, outcome, decisions, blockers, next steps)
• Semantic — project facts, tech gotchas, confirmed library behaviors, user preferences
• Procedural — ADRs with full Context / Decision / Rationale / Trade-offs / Status format
• Working — updated active.md with the next-session handoff state

Duplicate prevention

Before writing, memory-write searches the store and scores similarity:

Combined Workflow with Memory System

Context management handles the current session (keeping large outputs searchable without burning context). The memory system handles cross-session persistence (remembering decisions, facts, and workflows). They complement each other:

Session start:
  1. /memory-recall                           <- load long-term context
  2. ctx_checkpoint.py load --project .       <- load session checkpoint (if resuming)

During session:
  3. ctx_compress.py + ctx_index.py           <- manage large outputs
  4. ctx_search.py                            <- retrieve indexed snippets

Session end:
  5. ctx_checkpoint.py save --project .       <- save session state
  6. /memory-write                            <- persist decisions and facts

---