context-mode 0.9.21 → 1.0.0

package/hooks/vscode-copilot/posttooluse.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot PostToolUse hook — session event capture.
+ *
+ * Captures session events from tool calls (13 categories) and stores
+ * them in the per-project SessionDB for later resume snapshot building.
+ *
+ * Must be fast (<20ms). No network, no LLM, just SQLite writes.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath, getProjectDir, VSCODE_OPTS } from "../session-helpers.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "..", "build", "session");
+const OPTS = VSCODE_OPTS;
+const DEBUG_LOG = join(homedir(), ".vscode", "context-mode", "posttooluse-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] CALL: ${input.tool_name}\n`);
+
+  const { extractEvents } = await import(join(PKG_SESSION, "extract.js"));
+  const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+
+  const dbPath = getSessionDBPath(OPTS);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, getProjectDir(OPTS));
+
+  const events = extractEvents({
+    tool_name: input.tool_name,
+    tool_input: input.tool_input ?? {},
+    tool_response: typeof input.tool_response === "string"
+      ? input.tool_response
+      : JSON.stringify(input.tool_response ?? ""),
+    tool_output: input.tool_output,
+  });
+
+  for (const event of events) {
+    db.insertEvent(sessionId, event, "PostToolUse");
+  }
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${input.tool_name} → ${events.length} events\n`);
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ERR: ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PostToolUse — no stdout output

package/hooks/vscode-copilot/precompact.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot PreCompact hook — snapshot generation.
+ *
+ * Triggered when VS Code Copilot is about to compact the conversation.
+ * Reads all captured session events, builds a priority-sorted resume
+ * snapshot (<2KB XML), and stores it for injection after compact.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath, VSCODE_OPTS } from "../session-helpers.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "..", "build", "session");
+const OPTS = VSCODE_OPTS;
+const DEBUG_LOG = join(homedir(), ".vscode", "context-mode", "precompact-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  const { buildResumeSnapshot } = await import(join(PKG_SESSION, "snapshot.js"));
+  const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+
+  const dbPath = getSessionDBPath(OPTS);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+  }
+
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PreCompact — no stdout output needed

package/hooks/vscode-copilot/pretooluse.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot PreToolUse hook for context-mode
+ * Thin wrapper — uses shared routing core, no self-heal, no Claude Code-specific logic.
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readStdin } from "../core/stdin.mjs";
+import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { formatDecision } from "../core/formatters.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+const raw = await readStdin();
+const input = JSON.parse(raw);
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+
+const decision = routePreToolUse(tool, toolInput, process.env.VSCODE_CWD || process.env.CLAUDE_PROJECT_DIR);
+const response = formatDecision("vscode-copilot", decision);
+if (response !== null) {
+  process.stdout.write(JSON.stringify(response) + "\n");
+}

package/hooks/vscode-copilot/sessionstart.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot SessionStart hook for context-mode
+ *
+ * Session lifecycle management:
+ * - "startup"  → Cleanup old sessions, capture instruction file rules
+ * - "compact"  → Write events file, inject session knowledge directive
+ * - "resume"   → Load previous session events, inject directive
+ * - "clear"    → No action needed
+ */
+
+import { ROUTING_BLOCK } from "../routing-block.mjs";
+import { writeSessionEventsFile, buildSessionDirective, getAllProjectEvents } from "../session-directive.mjs";
+import {
+  readStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
+  getProjectDir, VSCODE_OPTS,
+} from "../session-helpers.mjs";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+
+const HOOK_DIR = new URL(".", import.meta.url).pathname;
+const PKG_SESSION = join(HOOK_DIR, "..", "..", "build", "session");
+const OPTS = VSCODE_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+  const source = input.source ?? "startup";
+
+  if (source === "compact") {
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+    const resume = db.getResume(sessionId);
+
+    if (resume && !resume.consumed) {
+      db.markResumeConsumed(sessionId);
+    }
+
+    const events = getAllProjectEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective("compact", eventMeta);
+    }
+
+    db.close();
+  } else if (source === "resume") {
+    try { unlinkSync(getCleanupFlagPath(OPTS)); } catch { /* no flag */ }
+
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+
+    const events = getAllProjectEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective("resume", eventMeta);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath(OPTS)); } catch { /* no stale file */ }
+
+    const cleanupFlag = getCleanupFlagPath(OPTS);
+    let previousWasFresh = false;
+    try { readFileSync(cleanupFlag); previousWasFresh = true; } catch { /* no flag */ }
+
+    if (previousWasFresh) {
+      db.cleanupOldSessions(0);
+    } else {
+      db.cleanupOldSessions(7);
+    }
+    db.db.exec(`DELETE FROM session_events WHERE session_id NOT IN (SELECT session_id FROM session_meta)`);
+    writeFileSync(cleanupFlag, new Date().toISOString(), "utf-8");
+
+    const sessionId = getSessionId(input, OPTS);
+    const projectDir = getProjectDir(OPTS);
+    db.ensureSession(sessionId, projectDir);
+    const ruleFilePaths = [
+      join(projectDir, ".github", "copilot-instructions.md"),
+    ];
+    for (const p of ruleFilePaths) {
+      try {
+        const content = readFileSync(p, "utf-8");
+        if (content.trim()) {
+          db.insertEvent(sessionId, { type: "rule", category: "rule", data: p, priority: 1 });
+          db.insertEvent(sessionId, { type: "rule_content", category: "rule", data: content, priority: 1 });
+        }
+      } catch { /* file doesn't exist — skip */ }
+    }
+
+    db.close();
+  }
+  // "clear" — no action needed
+} catch (err) {
+  try {
+    const { appendFileSync } = await import("node:fs");
+    const { join: pjoin } = await import("node:path");
+    const { homedir: hd } = await import("node:os");
+    appendFileSync(
+      pjoin(hd(), ".vscode", "context-mode", "sessionstart-debug.log"),
+      `[${new Date().toISOString()}] ${err?.message || err}\n${err?.stack || ""}\n`,
+    );
+  } catch { /* ignore logging failure */ }
+}
+
+const output = `SessionStart:compact hook success: Success\nSessionStart hook additional context: \n${additionalContext}`;
+process.stdout.write(output);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "context-mode",
-  "version": "0.9.21",
+  "version": "1.0.0",
   "type": "module",
-  "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
+  "description": "MCP plugin that saves 98% of your context window. Works with Claude Code, Gemini CLI, VS Code Copilot, OpenCode, and Codex CLI. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
   "author": "Mert Koseoğlu",
   "license": "Elastic-2.0",
   "keywords": [
@@ -10,6 +10,10 @@
     "model-context-protocol",
     "claude",
     "claude-code",
+    "gemini-cli",
+    "vscode-copilot",
+    "opencode",
+    "codex-cli",
     "context-window",
     "sandbox",
     "code-execution",
@@ -18,16 +22,22 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/mksglu/claude-context-mode"
+    "url": "https://github.com/mksglu/context-mode"
+  },
+  "homepage": "https://github.com/mksglu/context-mode#readme",
+  "bugs": "https://github.com/mksglu/context-mode/issues",
+  "main": "./build/cli.js",
+  "exports": {
+    ".": "./build/cli.js",
+    "./plugin": "./build/opencode-plugin.js"
   },
-  "homepage": "https://github.com/mksglu/claude-context-mode#readme",
-  "bugs": "https://github.com/mksglu/claude-context-mode/issues",
   "bin": {
     "context-mode": "./build/cli.js"
   },
   "files": [
     "build",
     "hooks",
+    "configs",
     "server.bundle.mjs",
     "skills",
     ".claude-plugin",
@@ -44,20 +54,12 @@
     "setup": "npx tsx src/cli.ts setup",
     "doctor": "npx tsx src/cli.ts doctor",
     "typecheck": "tsc --noEmit",
-    "test": "npx tsx tests/executor.test.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "benchmark": "npx tsx tests/benchmark.ts",
     "test:use-cases": "npx tsx tests/use-cases.ts",
     "test:compare": "npx tsx tests/context-comparison.ts",
-    "test:ecosystem": "npx tsx tests/ecosystem-benchmark.ts",
-    "test:store": "npx tsx tests/store.test.ts",
-    "test:fuzzy": "npx tsx tests/fuzzy-search.test.ts",
-    "test:hooks": "npx tsx tests/hook-integration.test.ts",
-    "test:project-dir": "npx tsx tests/project-dir.test.ts",
-    "test:stream-cap": "npx tsx tests/stream-cap.test.ts",
-    "test:search-wiring": "npx tsx tests/search-wiring.test.ts",
-    "test:search-fallback": "npx tsx tests/search-fallback-integration.test.ts",
-    "test:turndown": "npx tsx tests/turndown.test.ts",
-    "test:all": "for f in tests/*.test.ts; do npx tsx \"$f\" || exit 1; done"
+    "test:ecosystem": "npx tsx tests/ecosystem-benchmark.ts"
   },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
@@ -75,6 +77,7 @@
     "@types/turndown": "^5.0.5",
     "esbuild": "^0.27.3",
     "tsx": "^4.21.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
   }
 }

package/skills/context-mode/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: context-mode
 description: |
-  Use context-mode tools (execute, execute_file) instead of Bash/cat when processing
+  Use context-mode tools (ctx_execute, ctx_execute_file) instead of Bash/cat when processing
   large outputs. Trigger phrases: "analyze logs", "summarize output", "process data",
   "parse JSON", "filter results", "extract errors", "check build output",
   "analyze dependencies", "process API response", "large file analysis",
@@ -37,7 +37,7 @@ Bash whitelist (safe to run directly):
 - **Package management**: `npm install`, `npm publish`, `pip install`
 - **Simple output**: `echo`, `printf`
 
-**Everything else → `execute` or `execute_file`.** Any command that reads, queries, fetches, lists, logs, tests, builds, diffs, inspects, or calls an external service. This includes ALL CLIs (gh, aws, kubectl, docker, terraform, wrangler, fly, heroku, gcloud, etc.) — there are thousands and we cannot list them all.
+**Everything else → `ctx_execute` or `ctx_execute_file`.** Any command that reads, queries, fetches, lists, logs, tests, builds, diffs, inspects, or calls an external service. This includes ALL CLIs (gh, aws, kubectl, docker, terraform, wrangler, fly, heroku, gcloud, etc.) — there are thousands and we cannot list them all.
 
 **When uncertain, use context-mode.** Every KB of unnecessary context reduces the quality and speed of the entire session.
 
@@ -50,16 +50,16 @@ About to run a command / read a file / call an API?
 │   └── Use Bash
 │
 ├── Output MIGHT be large or you're UNSURE?
-│   └── Use context-mode execute or execute_file
+│   └── Use context-mode ctx_execute or ctx_execute_file
 │
 ├── Fetching web documentation or HTML page?
-│   └── Use fetch_and_index → search
+│   └── Use ctx_fetch_and_index → ctx_search
 │
 ├── Using Playwright (navigate, snapshot, console, network)?
 │   └── ALWAYS use filename parameter to save to file, then:
-│       browser_snapshot(filename) → index(path) or execute_file(path)
-│       browser_console_messages(filename) → execute_file(path)
-│       browser_network_requests(filename) → execute_file(path)
+│       browser_snapshot(filename) → ctx_index(path) or ctx_execute_file(path)
+│       browser_console_messages(filename) → ctx_execute_file(path)
+│       browser_network_requests(filename) → ctx_execute_file(path)
 │       ⚠ browser_navigate returns a snapshot automatically — ignore it,
 │         use browser_snapshot(filename) for any inspection.
 │       ⚠ Playwright MCP uses a SINGLE browser instance — NOT parallel-safe.
@@ -74,34 +74,34 @@ About to run a command / read a file / call an API?
 │
 ├── Processing output from another MCP tool (Context7, GitHub API, etc.)?
 │   ├── Output already in context from a previous tool call?
-│   │   └── Use it directly. Do NOT re-index with index(content: ...).
+│   │   └── Use it directly. Do NOT re-index with ctx_index(content: ...).
 │   ├── Need to search the output multiple times?
-│   │   └── Save to file via execute, then index(path) → search
+│   │   └── Save to file via ctx_execute, then ctx_index(path) → ctx_search
 │   └── One-shot extraction?
-│       └── Save to file via execute, then execute_file(path)
+│       └── Save to file via ctx_execute, then ctx_execute_file(path)
 │
 └── Reading a file to analyze/summarize (not edit)?
-    └── Use execute_file (file loads into FILE_CONTENT, not context)
+    └── Use ctx_execute_file (file loads into FILE_CONTENT, not context)
 ```
 
 ## When to Use Each Tool
 
 | Situation | Tool | Example |
 |-----------|------|---------|
-| Hit an API endpoint | `execute` | `fetch('http://localhost:3000/api/orders')` |
-| Run CLI that returns data | `execute` | `gh pr list`, `aws s3 ls`, `kubectl get pods` |
-| Run tests | `execute` | `npm test`, `pytest`, `go test ./...` |
-| Git operations | `execute` | `git log --oneline -50`, `git diff HEAD~5` |
-| Docker/K8s inspection | `execute` | `docker stats --no-stream`, `kubectl describe pod` |
-| Read a log file | `execute_file` | Parse access.log, error.log, build output |
-| Read a data file | `execute_file` | Analyze CSV, JSON, YAML, XML |
-| Read source code to analyze | `execute_file` | Count functions, find patterns, extract metrics |
-| Fetch web docs | `fetch_and_index` | Index React/Next.js/Zod docs, then search |
-| Playwright snapshot | `browser_snapshot(filename)` → `index(path)` → `search` | Save to file, index server-side, query |
-| Playwright snapshot (one-shot) | `browser_snapshot(filename)` → `execute_file(path)` | Save to file, extract in sandbox |
-| Playwright console/network | `browser_*(filename)` → `execute_file(path)` | Save to file, analyze in sandbox |
+| Hit an API endpoint | `ctx_execute` | `fetch('http://localhost:3000/api/orders')` |
+| Run CLI that returns data | `ctx_execute` | `gh pr list`, `aws s3 ls`, `kubectl get pods` |
+| Run tests | `ctx_execute` | `npm test`, `pytest`, `go test ./...` |
+| Git operations | `ctx_execute` | `git log --oneline -50`, `git diff HEAD~5` |
+| Docker/K8s inspection | `ctx_execute` | `docker stats --no-stream`, `kubectl describe pod` |
+| Read a log file | `ctx_execute_file` | Parse access.log, error.log, build output |
+| Read a data file | `ctx_execute_file` | Analyze CSV, JSON, YAML, XML |
+| Read source code to analyze | `ctx_execute_file` | Count functions, find patterns, extract metrics |
+| Fetch web docs | `ctx_fetch_and_index` | Index React/Next.js/Zod docs, then search |
+| Playwright snapshot | `browser_snapshot(filename)` → `ctx_index(path)` → `ctx_search` | Save to file, index server-side, query |
+| Playwright snapshot (one-shot) | `browser_snapshot(filename)` → `ctx_execute_file(path)` | Save to file, extract in sandbox |
+| Playwright console/network | `browser_*(filename)` → `ctx_execute_file(path)` | Save to file, analyze in sandbox |
 | MCP output (already in context) | Use directly | Don't re-index — it's already loaded |
-| MCP output (need multi-query) | `execute` to save → `index(path)` → `search` | Save to file first, index server-side |
+| MCP output (need multi-query) | `ctx_execute` to save → `ctx_index(path)` → `ctx_search` | Save to file first, index server-side |
 
 ## Automatic Triggers
 
@@ -134,12 +134,12 @@ Use context-mode for ANY of these, without being asked:
 - **Always use `source` parameter** when multiple docs are indexed to avoid cross-source contamination
   - Partial match works: `source: "Node"` matches `"Node.js v22 CHANGELOG"`
 - **Always use `queries` array** — batch ALL search questions in ONE call:
-  - `search(queries: ["transform pipe", "refine superRefine", "coerce codec"], source: "Zod")`
-  - NEVER make multiple separate search() calls — put all queries in one array
+  - `ctx_search(queries: ["transform pipe", "refine superRefine", "coerce codec"], source: "Zod")`
+  - NEVER make multiple separate ctx_search() calls — put all queries in one array
 
 ## External Documentation
 
-- **Always use `fetch_and_index`** for external docs — NEVER `cat` or `execute` with local paths for packages you don't own
+- **Always use `ctx_fetch_and_index`** for external docs — NEVER `cat` or `ctx_execute` with local paths for packages you don't own
 - For GitHub-hosted projects, use the raw URL: `https://raw.githubusercontent.com/org/repo/main/CHANGELOG.md`
 - After indexing, use the `source` parameter in search to scope results to that specific document
 
@@ -150,7 +150,7 @@ Use context-mode for ANY of these, without being asked:
 3. **Be specific in output.** Print bug details with IDs, line numbers, exact values — not just counts.
 4. **For files you need to EDIT**: Use the normal Read tool. context-mode is for analysis, not editing.
 5. **For Bash whitelist commands only**: Use Bash for file mutations, git writes, navigation, process control, package install, and echo. Everything else goes through context-mode.
-6. **Never use `index(content: large_data)`.** Use `index(path: ...)` to read files server-side. The `content` parameter sends data through context as a tool parameter — use it only for small inline text.
+6. **Never use `ctx_index(content: large_data)`.** Use `ctx_index(path: ...)` to read files server-side. The `content` parameter sends data through context as a tool parameter — use it only for small inline text.
 7. **Always use `filename` parameter** on Playwright tools (`browser_snapshot`, `browser_console_messages`, `browser_network_requests`). Without it, the full output enters context.
 8. **Don't re-index data already in context.** If an MCP tool returned data in a previous response, it's already loaded — use it directly or save to file first.
 
@@ -162,7 +162,7 @@ Use context-mode for ANY of these, without being asked:
     NEVER return large raw datasets directly to context.
   </critical_rule>
   <workflow>
-    LargeDataTool(filename: "path") → mcp__context-mode__index(path: "path") → search()
+    LargeDataTool(filename: "path") → mcp__context-mode__ctx_index(path: "path") → ctx_search()
   </workflow>
 </sandboxed_data_workflow>
 
@@ -200,7 +200,7 @@ gh pr list --json number,title,state,reviewDecision --jq '.[] | "\(.number) [\(.
 
 ### Read and analyze a large file
 ```python
-# FILE_CONTENT is pre-loaded by execute_file
+# FILE_CONTENT is pre-loaded by ctx_execute_file
 import json
 data = json.loads(FILE_CONTENT)
 print(f"Records: {len(data)}")
@@ -211,9 +211,9 @@ print(f"Records: {len(data)}")
 
 **When a task involves Playwright snapshots, screenshots, or page inspection, ALWAYS route through file → sandbox.**
 
-Playwright `browser_snapshot` returns 10K–135K tokens of accessibility tree data. Calling it without `filename` dumps all of that into context. Passing the output to `index(content: ...)` sends it into context a SECOND time as a parameter. Both are wrong.
+Playwright `browser_snapshot` returns 10K–135K tokens of accessibility tree data. Calling it without `filename` dumps all of that into context. Passing the output to `ctx_index(content: ...)` sends it into context a SECOND time as a parameter. Both are wrong.
 
-**The key insight**: `browser_snapshot` has a `filename` parameter that saves to file instead of returning to context. `index` has a `path` parameter that reads files server-side. `execute_file` processes files in a sandbox. **None of these touch context.**
+**The key insight**: `browser_snapshot` has a `filename` parameter that saves to file instead of returning to context. `ctx_index` has a `path` parameter that reads files server-side. `ctx_execute_file` processes files in a sandbox. **None of these touch context.**
 
 ### Workflow A: Snapshot → File → Index → Search (multiple queries)
 
@@ -221,10 +221,10 @@ Playwright `browser_snapshot` returns 10K–135K tokens of accessibility tree da
 Step 1: browser_snapshot(filename: "/tmp/playwright-snapshot.md")
         → saves to file, returns ~50B confirmation (NOT 135K tokens)
 
-Step 2: index(path: "/tmp/playwright-snapshot.md", source: "Playwright snapshot")
+Step 2: ctx_index(path: "/tmp/playwright-snapshot.md", source: "Playwright snapshot")
         → reads file SERVER-SIDE, indexes into FTS5, returns ~80B confirmation
 
-Step 3: search(queries: ["login form email password"], source: "Playwright")
+Step 3: ctx_search(queries: ["login form email password"], source: "Playwright")
         → returns only matching chunks (~300B)
 ```
 
@@ -236,7 +236,7 @@ Step 3: search(queries: ["login form email password"], source: "Playwright")
 Step 1: browser_snapshot(filename: "/tmp/playwright-snapshot.md")
         → saves to file, returns ~50B confirmation
 
-Step 2: execute_file(path: "/tmp/playwright-snapshot.md", language: "javascript", code: "
+Step 2: ctx_execute_file(path: "/tmp/playwright-snapshot.md", language: "javascript", code: "
           const links = [...FILE_CONTENT.matchAll(/- link \"([^\"]+)\"/g)].map(m => m[1]);
           const buttons = [...FILE_CONTENT.matchAll(/- button \"([^\"]+)\"/g)].map(m => m[1]);
           const inputs = [...FILE_CONTENT.matchAll(/- textbox|- checkbox|- radio/g)];
@@ -252,10 +252,10 @@ Step 2: execute_file(path: "/tmp/playwright-snapshot.md", language: "javascript"
 
 ```
 browser_console_messages(level: "error", filename: "/tmp/console.md")
-→ execute_file(path: "/tmp/console.md", ...) or index(path: "/tmp/console.md", ...)
+→ ctx_execute_file(path: "/tmp/console.md", ...) or ctx_index(path: "/tmp/console.md", ...)
 
 browser_network_requests(includeStatic: false, filename: "/tmp/network.md")
-→ execute_file(path: "/tmp/network.md", ...) or index(path: "/tmp/network.md", ...)
+→ ctx_execute_file(path: "/tmp/network.md", ...) or ctx_index(path: "/tmp/network.md", ...)
 ```
 
 ### CRITICAL: Why `filename` + `path` is mandatory
@@ -263,16 +263,16 @@ browser_network_requests(includeStatic: false, filename: "/tmp/network.md")
 | Approach | Context cost | Correct? |
 |----------|-------------|----------|
 | `browser_snapshot()` → raw into context | **135K tokens** | NO |
-| `browser_snapshot()` → `index(content: raw)` | **270K tokens** (doubled!) | NO |
-| `browser_snapshot(filename)` → `index(path)` → `search` | **~430B** | YES |
-| `browser_snapshot(filename)` → `execute_file(path)` | **~250B** | YES |
+| `browser_snapshot()` → `ctx_index(content: raw)` | **270K tokens** (doubled!) | NO |
+| `browser_snapshot(filename)` → `ctx_index(path)` → `ctx_search` | **~430B** | YES |
+| `browser_snapshot(filename)` → `ctx_execute_file(path)` | **~250B** | YES |
 
 ### Key Rule
 
 > **ALWAYS use `filename` parameter when calling `browser_snapshot`, `browser_console_messages`, or `browser_network_requests`.**
-> Then process via `index(path: ...)` or `execute_file(path: ...)` — never `index(content: ...)`.
+> Then process via `ctx_index(path: ...)` or `ctx_execute_file(path: ...)` — never `ctx_index(content: ...)`.
 >
-> Data flow: **Playwright → file → server-side read → context**. Never: **Playwright → context → index(content) → context again**.
+> Data flow: **Playwright → file → server-side read → context**. Never: **Playwright → context → ctx_index(content) → context again**.
 
 ## Subagent Usage
 
@@ -280,15 +280,15 @@ Subagents automatically receive context-mode tool routing via a PreToolUse hook.
 
 ## Anti-Patterns
 
-- Using `curl http://api/endpoint` via Bash → 50KB floods context. Use `execute` with fetch instead.
-- Using `cat large-file.json` via Bash → entire file in context. Use `execute_file` instead.
-- Using `gh pr list` via Bash → raw JSON in context. Use `execute` with `--jq` filter instead.
-- Piping Bash output through `| head -20` → you lose the rest. Use `execute` to analyze ALL data and print summary.
-- Running `npm test` via Bash → full test output in context. Use `execute` to capture and summarize.
+- Using `curl http://api/endpoint` via Bash → 50KB floods context. Use `ctx_execute` with fetch instead.
+- Using `cat large-file.json` via Bash → entire file in context. Use `ctx_execute_file` instead.
+- Using `gh pr list` via Bash → raw JSON in context. Use `ctx_execute` with `--jq` filter instead.
+- Piping Bash output through `| head -20` → you lose the rest. Use `ctx_execute` to analyze ALL data and print summary.
+- Running `npm test` via Bash → full test output in context. Use `ctx_execute` to capture and summarize.
 - Calling `browser_snapshot()` WITHOUT `filename` parameter → 135K tokens flood context. **Always** use `browser_snapshot(filename: "/tmp/snap.md")`.
 - Calling `browser_console_messages()` or `browser_network_requests()` WITHOUT `filename` → entire output floods context. **Always** use the `filename` parameter.
-- Passing ANY large data to `index(content: ...)` → data enters context as a parameter. **Always** use `index(path: ...)` to read server-side. The `content` parameter should only be used for small inline text you're composing yourself.
-- Calling an MCP tool (Context7 `query-docs`, GitHub API, etc.) then passing the response to `index(content: response)` → **doubles** context usage. The response is already in context — use it directly or save to file first.
+- Passing ANY large data to `ctx_index(content: ...)` → data enters context as a parameter. **Always** use `ctx_index(path: ...)` to read server-side. The `content` parameter should only be used for small inline text you're composing yourself.
+- Calling an MCP tool (Context7 `query-docs`, GitHub API, etc.) then passing the response to `ctx_index(content: response)` → **doubles** context usage. The response is already in context — use it directly or save to file first.
 - Ignoring `browser_navigate` auto-snapshot → navigation response includes a full page snapshot. Don't rely on it for inspection — call `browser_snapshot(filename)` separately.
 
 ## Reference Files

package/skills/{doctor → ctx-doctor}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: doctor
+name: ctx-doctor
 description: |
   Run context-mode diagnostics. Checks runtimes, hooks, FTS5,
   plugin registration, npm and marketplace versions.
-  Trigger: /context-mode:doctor
+  Trigger: /context-mode:ctx-doctor
 user_invocable: true
 ---
 
@@ -13,7 +13,7 @@ Run diagnostics and display results directly in the conversation.
 
 ## Instructions
 
-1. Derive the **plugin root** from this skill's base directory (go up 2 levels — remove `/skills/doctor`).
+1. Derive the **plugin root** from this skill's base directory (go up 2 levels — remove `/skills/ctx-doctor`).
 2. Run with Bash:
    ```
    npx tsx "<PLUGIN_ROOT>/src/cli.ts" doctor

package/skills/{stats → ctx-stats}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: stats
+name: ctx-stats
 description: |
   Show how much context window context-mode saved this session.
   Displays token consumption, context savings ratio, and per-tool breakdown.
-  Trigger: /context-mode:stats
+  Trigger: /context-mode:ctx-stats
 user_invocable: true
 ---
 
@@ -13,7 +13,7 @@ Show context savings for the current session.
 
 ## Instructions
 
-1. Call the `mcp__context-mode__stats` MCP tool (no parameters needed).
+1. Call the `mcp__context-mode__ctx_stats` MCP tool (no parameters needed).
 2. **CRITICAL**: You MUST copy-paste the ENTIRE tool output as markdown text directly into your response message. Do NOT summarize, do NOT collapse, do NOT paraphrase. The user must see the full tables without pressing ctrl+o. Copy every line exactly as returned by the tool.
 3. After the full output, add ONE sentence highlighting the key savings metric, e.g.:
    - "context-mode saved **12.4x** — 92% of data stayed in sandbox."

package/skills/{upgrade → ctx-upgrade}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: upgrade
+name: ctx-upgrade
 description: |
   Update context-mode from GitHub and fix hooks/settings.
   Pulls latest, builds, installs, updates npm global, configures hooks.
-  Trigger: /context-mode:upgrade
+  Trigger: /context-mode:ctx-upgrade
 user_invocable: true
 ---
 
@@ -13,7 +13,7 @@ Pull latest from GitHub and reinstall the plugin.
 
 ## Instructions
 
-1. Derive the **plugin root** from this skill's base directory (go up 2 levels — remove `/skills/upgrade`).
+1. Derive the **plugin root** from this skill's base directory (go up 2 levels — remove `/skills/ctx-upgrade`).
 2. Run with Bash:
    ```
    node "<PLUGIN_ROOT>/build/cli.js" upgrade