holycodex 0.2.1

package/plugin/runtime/rules.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { stdin, stdout } from "node:process";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+//#region src/rules-hook.ts
+var DEFAULT_RULE_LIMIT = 8e3;
+var DEFAULT_RESULT_LIMIT = 24e3;
+var SOURCES = [
+	".holycodex/rules",
+	".codex/rules",
+	".github/instructions"
+];
+async function loadRules(cwd, targetPath) {
+	if (process.env.HOLYCODEX_RULES_DISABLED === "1") return [];
+	const candidates = [join(cwd, "CONTEXT.md"), join(cwd, ".github", "copilot-instructions.md")];
+	for (const source of SOURCES) candidates.push(...await markdownFiles(join(cwd, source)));
+	const rules = [];
+	const seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	for (const path of candidates) {
+		const text = await readable(path);
+		if (text === void 0) continue;
+		const parsed = parseRule(text);
+		const staticSource = path.endsWith("CONTEXT.md") || path.endsWith("copilot-instructions.md");
+		if (!(targetPath === void 0 ? staticSource || parsed.alwaysApply : parsed.globs.some((glob) => globMatches(glob, relative(cwd, targetPath)))) || parsed.body.length === 0) continue;
+		const body = parsed.body.slice(0, numberFromEnv("HOLYCODEX_RULES_MAX_RULE_CHARS", DEFAULT_RULE_LIMIT));
+		const hash = createHash("sha256").update(body).digest("hex");
+		if (seen.has(hash)) continue;
+		if (total + body.length > numberFromEnv("HOLYCODEX_RULES_MAX_RESULT_CHARS", DEFAULT_RESULT_LIMIT)) break;
+		seen.add(hash);
+		total += body.length;
+		rules.push({
+			path,
+			body
+		});
+	}
+	return rules;
+}
+async function runRulesHook(input) {
+	if (typeof input.cwd !== "string" || typeof input.session_id !== "string") return "";
+	const event = input.hook_event_name;
+	const cache = cachePath(input.session_id);
+	if (event === "PostCompact") {
+		await rm(cache, { force: true });
+		return "";
+	}
+	const target = event === "PostToolUse" ? editPath(input.tool_input, input.cwd) : void 0;
+	if (event === "PostToolUse" && target === void 0) return "";
+	if (event !== "SessionStart" && event !== "UserPromptSubmit" && event !== "PostToolUse") return "";
+	const emitted = await filterCached(cache, await loadRules(input.cwd, target), typeof input.transcript_path === "string" ? await readable(input.transcript_path) ?? "" : "");
+	if (emitted.length === 0) return "";
+	const context = emitted.map((rule) => `Rule ${relative(input.cwd, rule.path)}:\n${rule.body}`).join("\n\n");
+	return `${JSON.stringify({ hookSpecificOutput: {
+		hookEventName: event,
+		additionalContext: context
+	} })}\n`;
+}
+function parseRule(text) {
+	if (!text.startsWith("---\n")) return {
+		alwaysApply: false,
+		globs: [],
+		body: text.trim()
+	};
+	const end = text.indexOf("\n---\n", 4);
+	if (end < 0) return {
+		alwaysApply: false,
+		globs: [],
+		body: text.trim()
+	};
+	const header = text.slice(4, end);
+	const globs = [...(/^globs:\s*(.+)$/m.exec(header)?.[1] ?? "").matchAll(/["']([^"']+)["']/g)].map((match) => match[1]).filter((value) => value !== void 0);
+	return {
+		alwaysApply: /^alwaysApply:\s*true\s*$/m.test(header),
+		globs,
+		body: text.slice(end + 5).trim()
+	};
+}
+function globMatches(glob, path) {
+	const normalized = path.replaceAll("\\", "/");
+	const pattern = glob.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("**", "\0").replaceAll("*", "[^/]*").replaceAll("\0", ".*");
+	return new RegExp(`^${pattern}$`).test(normalized);
+}
+async function markdownFiles(root) {
+	try {
+		const entries = await readdir(root, { withFileTypes: true });
+		return (await Promise.all(entries.map(async (entry) => {
+			const path = join(root, entry.name);
+			return entry.isDirectory() ? markdownFiles(path) : entry.isFile() && entry.name.endsWith(".md") ? [path] : [];
+		}))).flat();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+async function readable(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+		throw error;
+	}
+}
+function editPath(value, cwd) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const input = value;
+	for (const key of [
+		"filePath",
+		"file_path",
+		"path",
+		"targetPath",
+		"target_path"
+	]) if (typeof input[key] === "string") return isAbsolute(input[key]) ? input[key] : resolve(cwd, input[key]);
+	const patch = typeof input.patch === "string" ? input.patch : typeof input.input === "string" ? input.input : void 0;
+	const path = patch === void 0 ? void 0 : /^\*\*\* (?:Add|Update) File: (.+)$/m.exec(patch)?.[1]?.trim();
+	return path === void 0 ? void 0 : resolve(cwd, path);
+}
+async function filterCached(path, rules, transcript) {
+	const previous = new Set(JSON.parse(await readable(path) ?? "[]"));
+	const emitted = rules.filter((rule) => !previous.has(hashRule(rule)) && !transcript.includes(rule.body));
+	for (const rule of emitted) previous.add(hashRule(rule));
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, JSON.stringify([...previous]), "utf8");
+	return emitted;
+}
+function hashRule(rule) {
+	return createHash("sha256").update(rule.body).digest("hex");
+}
+function cachePath(session) {
+	return join(process.env.PLUGIN_DATA ?? join(tmpdir(), "holycodex-plugin-data"), "rules", `${session.replaceAll(/[^A-Za-z0-9._-]/g, "_")}.json`);
+}
+function numberFromEnv(name, fallback) {
+	const value = Number(process.env[name]);
+	return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+//#endregion
+//#region src/rules-cli.ts
+var raw = "";
+stdin.setEncoding("utf8");
+for await (const chunk of stdin) raw += chunk;
+if (raw.trim()) {
+	const input = JSON.parse(raw);
+	if (typeof input === "object" && input !== null && !Array.isArray(input)) stdout.write(await runRulesHook(input));
+}
+//#endregion

package/plugin/runtime/src-tRIOClWZ.js

@@ -0,0 +1,209 @@
+//#region packages/mcp-stdio-core/src/record.ts
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region packages/mcp-stdio-core/src/responses.ts
+function successResponse(id, result) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+}
+function errorResponse(id, code, message, data) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: data === void 0 ? {
+			code,
+			message
+		} : {
+			code,
+			message,
+			data
+		}
+	};
+}
+function jsonRpcId(value) {
+	return typeof value === "string" || typeof value === "number" || value === null ? value : null;
+}
+function messageFromError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region packages/mcp-stdio-core/src/transport.ts
+var HEADER_SEPARATOR = Buffer.from("\r\n\r\n");
+async function* readStdioJsonRpcMessages(input) {
+	let buffer = Buffer.alloc(0);
+	for await (const chunk of input) {
+		buffer = Buffer.concat([buffer, bufferFromChunk(chunk)]);
+		while (true) {
+			const result = readNextMessage(buffer);
+			if (result.kind === "incomplete") break;
+			buffer = result.remaining;
+			if (result.message) yield result.message;
+		}
+	}
+	const trailing = buffer.toString("utf8").trim();
+	if (trailing.length > 0) yield parseJsonPayload(trailing, "line");
+}
+function writeStdioJsonRpcResponse(output, response, responseMode) {
+	const body = JSON.stringify(response);
+	if (responseMode === "framed") {
+		output.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+		return;
+	}
+	output.write(`${body}\n`);
+}
+function readNextMessage(buffer) {
+	if (buffer.length === 0) return { kind: "incomplete" };
+	return startsWithContentLength(buffer) ? readFramedMessage(buffer) : readLineMessage(buffer);
+}
+function readLineMessage(buffer) {
+	const newlineIndex = buffer.indexOf(10);
+	if (newlineIndex === -1) return { kind: "incomplete" };
+	const line = buffer.subarray(0, newlineIndex).toString("utf8").replace(/\r$/, "");
+	if (line.trim().length === 0) return {
+		kind: "complete",
+		remaining: buffer.subarray(newlineIndex + 1)
+	};
+	return {
+		kind: "complete",
+		message: parseJsonPayload(line, "line"),
+		remaining: buffer.subarray(newlineIndex + 1)
+	};
+}
+function readFramedMessage(buffer) {
+	const separatorIndex = buffer.indexOf(HEADER_SEPARATOR);
+	if (separatorIndex === -1) return { kind: "incomplete" };
+	const contentLength = parseContentLength(buffer.subarray(0, separatorIndex).toString("ascii"));
+	const bodyStart = separatorIndex + HEADER_SEPARATOR.length;
+	if (contentLength === void 0) return {
+		kind: "complete",
+		message: {
+			kind: "parse_error",
+			message: "Missing or invalid Content-Length header",
+			responseMode: "framed"
+		},
+		remaining: buffer.subarray(bodyStart)
+	};
+	const bodyEnd = bodyStart + contentLength;
+	if (buffer.length < bodyEnd) return { kind: "incomplete" };
+	return {
+		kind: "complete",
+		message: parseJsonPayload(buffer.subarray(bodyStart, bodyEnd).toString("utf8"), "framed"),
+		remaining: buffer.subarray(bodyEnd)
+	};
+}
+function startsWithContentLength(buffer) {
+	return buffer.subarray(0, 15).toString("ascii").toLowerCase() === "content-length:";
+}
+function parseContentLength(headers) {
+	for (const line of headers.split("\r\n")) {
+		const match = /^content-length:\s*(\d+)$/i.exec(line);
+		if (match === null) continue;
+		const value = match[1];
+		if (value === void 0) return void 0;
+		return Number(value);
+	}
+}
+function parseJsonPayload(payload, responseMode) {
+	try {
+		return {
+			kind: "request",
+			payload: JSON.parse(payload),
+			responseMode
+		};
+	} catch (error) {
+		return {
+			kind: "parse_error",
+			message: error instanceof Error ? error.message : String(error),
+			responseMode
+		};
+	}
+}
+function bufferFromChunk(chunk) {
+	if (Buffer.isBuffer(chunk)) return chunk;
+	if (typeof chunk === "string") return Buffer.from(chunk);
+	throw new TypeError(`Unsupported stdio chunk type: ${typeof chunk}`);
+}
+//#endregion
+//#region packages/mcp-stdio-core/src/server.ts
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 6e4;
+var noopLog = () => {};
+async function runJsonRpcStdioServer(config) {
+	const log = config.log ?? noopLog;
+	const idleTimeoutMs = config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+	const idleTimer = createIdleTimer(idleTimeoutMs, log, config.onIdleTimeout);
+	log("stdio_started", {
+		cwd: process.cwd(),
+		idle_timeout_ms: idleTimeoutMs
+	});
+	idleTimer.arm();
+	try {
+		for await (const message of readStdioJsonRpcMessages(config.input)) {
+			if (idleTimer.closed()) break;
+			idleTimer.arm();
+			if (message.kind === "parse_error") {
+				handleParseError(message, config, log);
+				continue;
+			}
+			await handleRequest(message, config, log);
+		}
+	} finally {
+		idleTimer.clear();
+		log("stdio_stopped");
+	}
+}
+function handleParseError(message, config, log) {
+	log("parse_error", { message: message.message });
+	const response = config.parseErrorResponse?.(message.message) ?? errorResponse(null, -32700, "Parse error", message.message);
+	if (response !== void 0) writeStdioJsonRpcResponse(config.output, response, message.responseMode);
+}
+async function handleRequest(message, config, log) {
+	const parsed = message.payload;
+	const id = isPlainRecord(parsed) ? jsonRpcId(parsed["id"]) : null;
+	const method = isPlainRecord(parsed) && typeof parsed["method"] === "string" ? parsed["method"] : null;
+	log("request", {
+		id: id === null ? null : String(id),
+		method
+	});
+	try {
+		const response = await config.handler(parsed, config.handlerOptions);
+		if (response === void 0) return;
+		writeStdioJsonRpcResponse(config.output, response, message.responseMode);
+		log("response", {
+			id: String(response.id),
+			method,
+			is_error: response.error !== void 0
+		});
+	} catch (error) {
+		if (config.onHandlerError === void 0) throw error;
+		config.onHandlerError(error);
+	}
+}
+function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
+	let timer = null;
+	let isClosed = false;
+	return {
+		arm: () => {
+			if (timer !== null) clearTimeout(timer);
+			if (idleTimeoutMs <= 0) return;
+			timer = setTimeout(() => {
+				isClosed = true;
+				log("idle_timeout", { idle_timeout_ms: idleTimeoutMs });
+				onIdleTimeout?.();
+			}, idleTimeoutMs);
+			timer.unref();
+		},
+		clear: () => {
+			if (timer === null) return;
+			clearTimeout(timer);
+			timer = null;
+		},
+		closed: () => isClosed
+	};
+}
+//#endregion
+export { successResponse as a, messageFromError as i, errorResponse as n, isPlainRecord as o, jsonRpcId as r, runJsonRpcStdioServer as t };

package/plugin/skills/ast-grep/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yeongyu Kim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/plugin/skills/ast-grep/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: ast-grep
+description: AST-aware search and deterministic rewrite. Use when a code pattern depends on syntax shape or needs a safe repeatable codemod.
+---
+
+# ast-grep
+
+Use `sg` when target is syntax shape: function, call, class, import, missing `await`, empty catch, unsafe assertion, or codemod. Use `rg` for plain text.
+
+## Flow
+
+1. Name language and exact syntax shape.
+2. Start search-only. Use smallest pattern with metavariables.
+3. Inspect every match class. Add `inside`, `has`, `not`, or relational rule only when needed.
+4. Test rewrite on narrow path. Review diff.
+5. Apply deterministic rewrite. Run formatter, diagnostics, targeted tests.
+
+Use `sg run -p '<pattern>' -l <language> <path>` for simple search. Use YAML rule for constraints, relational matching, or reusable codemod. Never run write mode before match review. Never use regex replacement for syntax-bearing code.
+
+Load only needed reference: `patterns.md`, `yaml-rules.md`, `recipes.md`, `pitfalls.md`, `sgconfig.md`, `cli.md`, or `install.md`.

package/plugin/skills/ast-grep/references/cli.md

@@ -0,0 +1,3 @@
+# CLI
+
+Search: `sg run -p '<pattern>' -l <language> <path>`. Structured rule: `sg scan -r rule.yml <path>`. Rewrite uses `--rewrite '<fix>'`; add interactive/update flag only after reviewing matches. Check installed syntax with `sg --help` because flags vary by version.

package/plugin/skills/ast-grep/references/install.md

@@ -0,0 +1,3 @@
+# Install
+
+First run `sg --version`. If absent and user authorized install, use project/package-manager convention or official ast-grep package. Confirm executable and version. Never silently download or mutate global environment.

package/plugin/skills/ast-grep/references/patterns.md

@@ -0,0 +1,3 @@
+# Patterns
+
+Use code-shaped pattern in target language. `$A` captures one node; `$$$ARGS` captures many; `$_` ignores one. Start concrete, then replace only variable parts. Quote pattern in shell. If syntax fragment cannot parse alone, use `context` plus `selector` in YAML. Verify matches before rewrite.

package/plugin/skills/ast-grep/references/pitfalls.md

@@ -0,0 +1,3 @@
+# Pitfalls
+
+Text that looks alike may have different AST. Pattern may overmatch nested nodes, comments may not be nodes, and shell may expand `$`. Quote patterns. Specify language. Avoid `$$$` unless arity truly irrelevant. Never write on first query. After rewrite inspect diff and rerun search for leftovers.

package/plugin/skills/ast-grep/references/recipes.md

@@ -0,0 +1,9 @@
+# Recipes
+
+- Call: `pattern: logger.debug($A)`.
+- Any arguments: `pattern: console.log($$$ARGS)`.
+- Empty catch: match `catch ($E) {}` with language-correct syntax.
+- Missing await: match call plus `not`/`inside` constraint excluding await expression.
+- Import migration: match full import/require form; preserve captured module/name in fix.
+
+For each recipe: search narrow path, inspect variants, add constraint, dry review, write, format, test.

package/plugin/skills/ast-grep/references/sgconfig.md

@@ -0,0 +1,3 @@
+# sgconfig
+
+Use `sgconfig.yml` only for reusable project rules. Declare `ruleDirs` and optional test directories using repository-relative paths. Do not add config for one query. Run config-backed scan/test from repository root.

package/plugin/skills/ast-grep/references/yaml-rules.md

@@ -0,0 +1,3 @@
+# YAML rules
+
+Minimum rule: `id`, `language`, `rule`. Compose with `all`, `any`, `not`; relate with `inside`, `has`, `precedes`, `follows`; constrain captures with `constraints`. Add `fix` only after search result is exact. Keep one semantic purpose per rule. Test positive and negative fixtures with `sg test`.

package/plugin/skills/caveman/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julius Brussee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/plugin/skills/caveman/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode. Cuts output tokens 65% (measured) by speaking like caveman
+  while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra,
+  wenyan-lite, wenyan-full, wenyan-ultra.
+  Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens",
+  "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked — quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) — tokenizer split them same as full word: zero token saved, reader still decode. Full word cheaper AND clearer. No causal arrows (→) either — own token, save nothing. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Preserve user's dominant language. User write Portuguese → reply Portuguese caveman. User write Spanish → reply Spanish caveman. Compress the style, not the language. No forced English openings or status phrases. ALWAYS keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim — unless user explicitly ask for translation.
+
+No self-reference. Never name or announce the style. No "caveman mode on", "me caveman think", no third-person caveman tags. Output caveman-only — never normal answer plus "Caveman:" recap. Exception: user explicitly ask what the mode is.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level            | What change                                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **lite**         | No filler/hedging. Keep articles + full sentences. Professional but tight                                                                                                                                                                                                                                                    |
+| **full**         | Drop articles, fragments OK, short synonyms. Classic caveman. No tool-call narration, no decorative tables/emoji, no long raw error-log dumps unless asked. Standard acronyms OK; no invented abbreviations                                                                                                                  |
+| **ultra**        | Strip conjunctions when cause-then-effect stay unambiguous. One word when one word enough. State each fact once. NO prose abbreviations (cfg/impl/req/res/fn/auth), NO arrows (X → Y) — measured zero token saving under tokenizer, cost decode clarity. Code symbols, function names, API names, error strings: never touch |
+| **wenyan-lite**  | Semi-classical. Drop filler/hedging but keep grammar structure, classical register                                                                                                                                                                                                                                           |
+| **wenyan-full**  | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其)                                                                                                                                         |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse                                                                                                                                                                                                                                  |
+
+Example — "Why React component re-render?"
+
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop, new ref, re-render. `useMemo`."
+- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
+- wenyan-full: "每繪新生對象參照，故重繪；以 useMemo 包之則免。"
+- wenyan-ultra: "新參照則重繪。useMemo 包之。"
+
+Example — "Explain database connection pooling."
+
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool reuse open DB connections. No per-request handshake."
+- wenyan-full: "池蓄已開之連，不逐請而新開，省握手之費。"
+- wenyan-ultra: "池蓄連，免逐請新開，省握手。"
+
+## Auto-Clarity
+
+Drop caveman when:
+
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g., `"migrate table drop column backup first"` — order unclear without articles/conjunctions)
+- User asks to clarify or repeats question
+
+Resume caveman after clear part done.
+
+Example — destructive op:
+
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+>
+> ```sql
+> DROP TABLE users;
+> ```
+>
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

package/plugin/skills/comment-checker/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: comment-checker
+description: Use when Codex needs to understand or respond to automatic comment-checker feedback emitted after an edit-like PostToolUse hook.
+---
+
+# Codex Comment Checker
+
+The plugin registers a `PostToolUse` hook for successful `apply_patch`, `write`, `edit`, `multi_edit`, and `multiedit` calls.
+
+When comment-checker reports a warning after a patch, Codex receives blocking feedback and should fix or explain the flagged comment before moving on.
+
+## Scope
+
+- No MCP tool is exposed.
+- Non-edit tools are ignored by this plugin.
+- Missing checker binaries emit no hook output so normal Codex work can continue.

package/plugin/skills/compress/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: compress
+description: Rewrite any text, skill, prompt, documentation, instructions, prose, notes, or structured content to use fewer words and tokens while preserving meaning, facts, constraints, safety, tone, and required structure. Use when asked to compress, condense, tighten, shorten, de-duplicate, optimize token usage, or rewrite using caveman principles.
+---
+
+# Compress
+
+Rewrite with caveman principles: all substance stays; filler dies. Do not automatically adopt caveman voice unless user requests it. Default output remains clear, grammatical, and natural.
+
+## Workflow
+
+1. Identify purpose, audience, format, required facts, exact strings, constraints, decision gates, safety warnings, examples, links, and tone.
+2. Remove repetition, throat-clearing, filler, redundant headings, obvious explanation, decorative adjectives, and verbose transitions.
+3. Merge related rules. Prefer direct verbs, short familiar words, compact lists, and one statement per fact.
+4. Preserve technical names, code, commands, paths, APIs, error strings, numbers, citations, legal terms, and user-defined terminology exactly unless correction is requested.
+5. Preserve ordering when sequence matters. Keep full grammar where compression could create ambiguity, especially safety, irreversible actions, legal/medical guidance, or multi-step operations.
+6. Check compressed output against source: no lost requirement, changed meaning, weakened prohibition, invented claim, broken reference, or altered scope.
+
+## Content Rules
+
+- **Skills/prompts:** preserve YAML frontmatter, trigger coverage, imperative instructions, tool/resource references, permissions, stop conditions, and validation. Remove duplicated “when to use” prose from body when frontmatter already carries it.
+- **Code/config:** never compress syntax or identifiers unless explicitly asked to refactor. Compress surrounding explanation only.
+- **Prose/docs:** preserve thesis, evidence, nuance, attribution, and intended tone. Remove repeated framing and examples that add no distinct value.
+- **Lists/tables:** merge duplicates; keep mappings and comparisons when format improves scan speed.
+
+If user sets length/ratio/style, follow it. Otherwise aim for largest safe reduction, not shortest possible output. Report before/after size only when useful or requested.

package/plugin/skills/debugging/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: debugging
+description: Reproduce, isolate, prove, and minimally fix runtime bugs. Use for crashes, wrong behavior, hangs, races, leaks, or unexplained performance.
+---
+
+# Debugging
+
+No guess-fix loop.
+
+1. Reproduce exact symptom with smallest command.
+2. Minimize input, environment, and path.
+3. Write at least three plausible causes from distinct layers.
+4. Rank by evidence and cheap falsifier.
+5. Instrument narrow boundary. Capture values, ordering, ownership, timing, process state.
+6. Disprove causes. After two failed rounds, change angle; do not add reviewer or oracle agent.
+7. Confirm root cause with evidence that predicts symptom.
+8. Add failing public-behavior regression test.
+9. Make minimum root fix.
+10. Run targeted test, then proportional suite. Remove temporary instrumentation.
+
+No sleeps for async proof. Use event, signal, fake clock, trace, debugger, profiler, sanitizer, or deterministic fixture. No implementation before root cause unless user explicitly asks for mitigation.
+
+Load only relevant runtime/tool reference under `references/`. Report reproduction, hypotheses rejected, root cause, proof, fix, checks, residual uncertainty.

package/plugin/skills/debugging/references/runtimes/README.md

@@ -0,0 +1,9 @@
+# Runtime probes
+
+- Node/Bun: reproduce with exact runtime/version; enable source maps and warnings; inspect event ordering, handles, promises, memory snapshots, CPU profile. Distinguish module resolution, transpilation, runtime, and external process.
+- Python: use traceback with causes, `faulthandler`, debugger, allocation/profile tools. Check interpreter/env, import path, sync blocking in async loop, resource ownership.
+- Rust/native: debug symbols; backtrace, debugger, sanitizer, Miri, profiler as symptom requires. Check UB, ownership, ABI, signal/thread ordering.
+- Go: race detector, pprof, trace, goroutine dump. Check cancellation, channel ownership, leaked goroutines, copied synchronization.
+- Bundled JS binary: reproduce source and bundle separately; verify target/runtime/externalization and source map. Inspect generated boundary, not minified noise first.
+
+Capture smallest evidence that separates hypotheses. Remove probe after proof.

package/plugin/skills/debugging/references/tools/README.md

@@ -0,0 +1,8 @@
+# Tool choice
+
+- Playwright: deterministic browser flow, console/network/DOM/screenshot evidence.
+- GDB/pwndbg: native crash, registers, stack, memory, heap; local authorized target only.
+- Ghidra: static binary control/data flow when source absent; pair claims with runtime proof when possible.
+- pwntools: local protocol/process PoC with bounded input and timeout; never destructive or third-party.
+
+Use least invasive tool that falsifies a hypothesis. Record exact command/version and preserve a safe reproducer.