supipowers 0.7.1 → 0.7.3

package/bin/install.mjs

@@ -196,6 +196,55 @@ async function main() {
     }
   }
 
+  // ── Step 2b: Register context-mode MCP server (if installed) ──
+
+  const ctxSpinner = spinner();
+  ctxSpinner.start("Checking for context-mode...");
+
+  // Find context-mode installation (Claude Code plugin cache)
+  const ctxCacheBase = join(homedir(), ".claude", "plugins", "cache", "context-mode", "context-mode");
+  let ctxInstallPath = null;
+  if (existsSync(ctxCacheBase)) {
+    // Find the latest version directory
+    const versions = readdirSync(ctxCacheBase, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name)
+      .sort()
+      .reverse();
+    if (versions.length > 0) {
+      const candidate = join(ctxCacheBase, versions[0], "start.mjs");
+      if (existsSync(candidate)) {
+        ctxInstallPath = join(ctxCacheBase, versions[0]);
+      }
+    }
+  }
+
+  if (ctxInstallPath) {
+    // Register as MCP server in ~/.omp/agent/mcp.json
+    const mcpConfigPath = join(homedir(), ".omp", "agent", "mcp.json");
+    let mcpConfig = { mcpServers: {} };
+    if (existsSync(mcpConfigPath)) {
+      try {
+        mcpConfig = JSON.parse(readFileSync(mcpConfigPath, "utf8"));
+        if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+      } catch {
+        mcpConfig = { mcpServers: {} };
+      }
+    }
+
+    const startMjs = join(ctxInstallPath, "start.mjs");
+    mcpConfig.mcpServers["context-mode"] = {
+      command: "node",
+      args: [startMjs],
+    };
+
+    const { writeFileSync: writeFs } = await import("node:fs");
+    writeFs(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+    ctxSpinner.stop(`context-mode registered as MCP server (${ctxInstallPath})`);
+  } else {
+    ctxSpinner.stop("context-mode not found (install it as a Claude Code plugin for context window protection)");
+  }
+
   // ── Step 3: LSP setup (optional, skipped with --skip-lsp) ──
 
   if (skipLsp) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "OMP-native workflow extension inspired by supipowers.",
   "type": "module",
   "scripts": {

package/skills/context-mode/SKILL.md

@@ -1,38 +1,77 @@
-# Context Mode — Tool Routing Instructions
+# context-mode — MANDATORY routing rules
 
-When context-mode sandbox tools are available, prefer them over raw tool calls to keep your context window lean.
+You have context-mode MCP tools available. These rules are NOT optional — they protect your context window from flooding. A single unrouted command can dump 56 KB into context and waste the entire session.
 
-## Tool Selection Hierarchy
+## BLOCKED commands — do NOT attempt these
 
-Use context-mode tools in this priority order:
+### curl / wget — BLOCKED
+Any Bash command containing `curl` or `wget` is intercepted and replaced with an error message. Do NOT retry.
+Instead use:
+- `ctx_fetch_and_index(url, source)` to fetch and index web pages
+- `ctx_execute(language: "javascript", code: "const r = await fetch(...)")` to run HTTP calls in sandbox
 
-1. **ctx_batch_execute** — for multi-step operations. Runs multiple commands and searches in a single call.
-   - Use when: you need to run 2+ commands, or combine a command with a search
-   - Example: checking a build AND searching for a symbol
+### Inline HTTP — BLOCKED
+Any Bash command containing `fetch('http`, `requests.get(`, `requests.post(`, `http.get(`, or `http.request(` is intercepted and replaced with an error message. Do NOT retry with Bash.
+Instead use:
+- `ctx_execute(language, code)` to run HTTP calls in sandbox — only stdout enters context
 
-2. **ctx_search** — for querying previously indexed knowledge. No re-execution needed.
-   - Use when: you've already indexed data and need to find something in it
-   - Example: finding a function definition you indexed earlier
+### WebFetch / Fetch — BLOCKED
+WebFetch and Fetch calls are denied entirely.
+Instead use:
+- `ctx_fetch_and_index(url, source)` then `ctx_search(queries)` to query the indexed content
 
-3. **ctx_execute / ctx_execute_file** — for single commands or file processing.
-   - Use when: running one command whose output would be large
-   - Example: listing a directory, reading a large log file
+### Grep — BLOCKED
+Grep calls are intercepted and blocked. Do NOT retry with Grep.
+Instead use:
+- `ctx_search(queries: ["<pattern>"])` to search indexed content
+- `ctx_batch_execute(commands, queries)` to run searches and return compressed results
+- `ctx_execute(language: "shell", code: "grep ...")` to run searches in sandbox
 
-4. **Raw Bash/Read/Grep** — only when necessary.
-   - Use when: editing files (Read before Edit), running build/test commands where real-time output matters, or when the output is known to be small
+### Find / Glob — BLOCKED
+Find/Glob calls are intercepted and blocked. Do NOT retry with Find/Glob.
+Instead use:
+- `ctx_execute(language: "shell", code: "find ...")` to run in sandbox
+- `ctx_batch_execute(commands, queries)` for multiple searches
 
-## Forbidden Patterns
+### Read (full-file, no limit) — BLOCKED
+Reading an entire file without a `limit` parameter is blocked.
+- If you need to **Edit** the file → re-call Read with `limit` parameter (e.g., `limit: 200`)
+- If you need to **analyze or explore** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context.
 
-- Do NOT use Bash for `curl`/`wget`/HTTP requests — use `ctx_fetch_and_index` instead
-- Do NOT use Read for analyzing large files (>100 lines) — use `ctx_execute_file` to process and summarize
-- Do NOT use Bash for directory listings with >20 expected files — use `ctx_execute`
+## REDIRECTED tools — use sandbox equivalents
 
-## Output Constraints
+### Bash (>20 lines output)
+Bash is ONLY for: `git`, `mkdir`, `rm`, `mv`, `cd`, `ls`, `npm install`, `pip install`, and other short-output commands.
+For everything else, use:
+- `ctx_batch_execute(commands, queries)` — run multiple commands + search in ONE call
+- `ctx_execute(language: "shell", code: "...")` — run in sandbox, only stdout enters context
 
-- Keep tool output responses under 500 words when possible
-- Write large artifacts (generated code, data dumps) to files rather than returning them inline
-- Prefer structured summaries over raw output
+### Read (for analysis)
+If you are reading a file to **Edit** it → Read with `limit` is correct (Edit needs content in context).
+If you are reading to **analyze, explore, or summarize** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context. The raw file content stays in the sandbox.
 
-## Sub-Agent Awareness
+## Tool selection hierarchy
 
-These routing instructions apply within sub-agent sessions. When you are a sub-agent dispatched by supipowers, follow the same tool preference hierarchy.
+1. **GATHER**: `ctx_batch_execute(commands, queries)` — Primary tool. Runs all commands, auto-indexes output, returns search results. ONE call replaces 30+ individual calls.
+2. **FOLLOW-UP**: `ctx_search(queries: ["q1", "q2", ...])` — Query indexed content. Pass ALL questions as array in ONE call.
+3. **PROCESSING**: `ctx_execute(language, code)` | `ctx_execute_file(path, language, code)` — Sandbox execution. Only stdout enters context.
+4. **WEB**: `ctx_fetch_and_index(url, source)` then `ctx_search(queries)` — Fetch, chunk, index, query. Raw HTML never enters context.
+5. **INDEX**: `ctx_index(content, source)` — Store content in FTS5 knowledge base for later search.
+
+## Subagent routing
+
+When spawning subagents (Agent/Task tool), the routing block is automatically injected into their prompt. Bash-type subagents are upgraded to general-purpose so they have access to MCP tools. You do NOT need to manually instruct subagents about context-mode.
+
+## Output constraints
+
+- Keep responses under 500 words.
+- Write artifacts (code, configs, PRDs) to FILES — never return them as inline text. Return only: file path + 1-line description.
+- When indexing content, use descriptive source labels so others can `ctx_search(source: "label")` later.
+
+## ctx commands
+
+| Command | Action |
+|---------|--------|
+| `ctx stats` | Call the `ctx_stats` MCP tool and display the full output verbatim |
+| `ctx doctor` | Call the `ctx_doctor` MCP tool, run the returned shell command, display as checklist |
+| `ctx upgrade` | Call the `ctx_upgrade` MCP tool, run the returned shell command, display as checklist |

package/src/context-mode/detector.ts

@@ -24,13 +24,26 @@ const TOOL_SUFFIXES: Array<[string, keyof ContextModeStatus["tools"]]> = [
 ];
 
 /**
- * Extract the short tool name from a potentially MCP-namespaced tool name.
- * MCP tools use the format: mcp__<server>__<tool_name>
- * Native tools use bare names like: lsp, bash, etc.
+ * Check if a tool name matches a context-mode tool suffix.
+ * Handles multiple naming conventions:
+ *   - Bare names: "ctx_execute"
+ *   - Claude Code MCP: "mcp__plugin_context-mode_context-mode__ctx_execute"
+ *   - OMP MCP: "mcp_context_mode_ctx_execute"
+ *
+ * We match by checking if the tool contains a known context-mode server
+ * prefix followed by the suffix, or is the bare suffix itself.
  */
-function getShortName(tool: string): string {
-  const lastSep = tool.lastIndexOf("__");
-  return lastSep >= 0 ? tool.slice(lastSep + 2) : tool;
+const CONTEXT_MODE_PREFIXES = [
+  "mcp__plugin_context-mode_context-mode__",  // Claude Code
+  "mcp_context_mode_",                        // OMP
+];
+
+function matchesSuffix(tool: string, suffix: string): boolean {
+  if (tool === suffix) return true;
+  for (const prefix of CONTEXT_MODE_PREFIXES) {
+    if (tool === prefix + suffix) return true;
+  }
+  return false;
 }
 
 /** Detect context-mode MCP tool availability from the active tools list */
@@ -45,9 +58,8 @@ export function detectContextMode(activeTools: string[]): ContextModeStatus {
   };
 
   for (const tool of activeTools) {
-    const shortName = getShortName(tool);
     for (const [suffix, key] of TOOL_SUFFIXES) {
-      if (shortName === suffix) {
+      if (matchesSuffix(tool, suffix)) {
         tools[key] = true;
         break;
       }

package/src/context-mode/hooks.ts

@@ -94,7 +94,8 @@ export function registerContextModeHooks(pi: ExtensionAPI, config: SupipowersCon
 
     // Phase 1: routing instructions
     if (!config.contextMode.routingInstructions) return;
-    if (!cachedStatus) cachedStatus = detectContextMode(pi.getActiveTools());
+    // Always re-detect: MCP tools may load after extension init
+    cachedStatus = detectContextMode(pi.getActiveTools());
     if (!cachedStatus.available) return;
 
     const skill = loadRoutingSkill();