@ccx-agent/opencode-ccx 0.1.0 → 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ccx-agent
+
+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/README.md

@@ -1,48 +1,66 @@
-# ccx — Coding Copilot, eXtended
+<p align="center">
+  <h1 align="center">ccx</h1>
+  <p align="center"><strong>Coding Copilot, eXtended</strong></p>
+  <p align="center">
+    An <a href="https://opencode.ai">OpenCode</a> plugin that makes your AI coding agent disciplined, verification-driven, and risk-aware.
+  </p>
+  <p align="center">
+    <a href="https://www.npmjs.com/package/@ccx-agent/opencode-ccx"><img src="https://img.shields.io/npm/v/@ccx-agent/opencode-ccx?style=flat-square&color=blue" alt="npm version"></a>
+    <a href="https://github.com/Rejudge-F/ccx/blob/main/LICENSE"><img src="https://img.shields.io/github/license/Rejudge-F/ccx?style=flat-square" alt="license"></a>
+  </p>
+</p>
 
-An [OpenCode](https://opencode.ai) plugin that turns your AI coding agent into a disciplined software engineer. ccx injects a complete behavioral framework — system prompt sections, specialized subagents, and safety hooks — so the agent writes less unnecessary code, verifies its own work, and thinks before running destructive commands.
+---
 
-## Why
+## The Problem
 
-Out of the box, LLM coding agents tend to over-engineer, skip verification, and act before thinking. ccx fixes this by injecting a set of behavioral constraints and specialized subagents into your OpenCode session:
+LLM coding agents tend to over-engineer, skip verification, and run destructive commands without thinking. They add abstractions nobody asked for, report "done" without testing, and `rm -rf` without blinking.
 
-- **Writes less, not more** — no speculative abstractions, no unrequested refactors, no gold-plating
-- **Verifies before reporting done** — an adversarial verification agent stress-tests implementations with real commands, not code reading
-- **Asks before destroying** — a risk guard flags `rm -rf`, `git push --force`, and other irreversible actions before they execute
-- **Delegates intelligently** — a coordinator agent decomposes complex tasks into research, implementation, and verification phases across parallel workers
+## The Solution
 
-## What You Get
+ccx injects a complete behavioral framework into your OpenCode agent — system prompt sections that enforce coding discipline, specialized subagents that verify and plan, and safety hooks that catch dangerous operations before they execute.
 
-| Component | What it does |
-|-----------|-------------|
-| **ccx** (primary agent) | Main agent with 7 composable system prompt sections governing coding discipline, risk awareness, tool usage, and output style |
-| **ccx-explore** | Read-only codebase search specialist. Fast parallel file/content search across large repos |
-| **ccx-plan** | Read-only software architect. Investigates code and produces step-by-step implementation plans with critical file lists |
-| **ccx-verification** | Adversarial verifier with VERDICT protocol (PASS/FAIL/PARTIAL). Runs builds, tests, linters, then tries to break things with boundary values, concurrency probes, and idempotency checks |
-| **ccx-general-purpose** | Multi-strategy task worker for anything that doesn't fit the specialists |
-| **ccx-coordinator** | Multi-agent orchestrator. Decomposes work into Research → Synthesis → Implementation → Verification phases across parallel workers |
-| **Risk Guard** | `tool.execute.before` hook that warns on destructive operations |
-| **Verification Reminder** | `tool.execute.after` hook that nudges verification after N file edits |
+**Before ccx:** Agent writes 200 lines, adds 3 helper files, says "done."
 
-## Install
+**After ccx:** Agent writes 40 lines, runs the tests, spawns a verification agent that tries to break it, then reports the VERDICT.
+
+---
+
+## Quick Start
+
+```bash
+opencode plugin @ccx-agent/opencode-ccx
+```
+
+That's it. Restart OpenCode, press `@`, select **ccx**.
+
+For global install (applies to all projects):
 
 ```bash
-bun add ccx
+opencode plugin @ccx-agent/opencode-ccx -g
 ```
 
-Add to your OpenCode config:
+### Manual Installation
+
+If you prefer manual setup, add to your `opencode.json`:
 
 ```jsonc
 // ~/.config/opencode/opencode.json
 {
   "plugin": [
-    "ccx"
-    // ... your other plugins
+    "@ccx-agent/opencode-ccx@0.1.0"
   ]
 }
 ```
 
-Or use a local build:
+### Development / Local Build
+
+```bash
+git clone https://github.com/Rejudge-F/ccx.git
+cd ccx && bun install && bun run build
+```
+
+Then in `opencode.json`:
 
 ```jsonc
 {
@@ -52,9 +70,63 @@ Or use a local build:
 }
 ```
 
-Restart OpenCode. Press `@` to see `ccx` in the agent list.
+---
+
+## What's Inside
+
+### Primary Agent: `ccx`
+
+The main agent comes with 7 composable system prompt sections:
+
+| Section | What it enforces |
+|---------|-----------------|
+| **intro** | Agent identity and trust boundary for untrusted content |
+| **system-rules** | Permission model, context compression, prompt injection awareness |
+| **doing-tasks** | Scope control — no unrequested features, no speculative abstractions, duplicate code > premature abstraction |
+| **actions** | Risk classification — reversible vs irreversible, local vs shared, ask before destroying |
+| **using-tools** | Dedicated tools over Bash, parallel tool calls, structured progress tracking |
+| **tone-style** | Concise output, no emojis, `file:line` references, `owner/repo#N` links |
+| **output-efficiency** | Lead with the answer, skip filler, report at milestones not continuously |
+
+### Subagents
+
+| Agent | Mode | Purpose |
+|-------|------|---------|
+| **ccx-explore** | read-only | Fast codebase search — parallel glob/grep/read across large repos |
+| **ccx-plan** | read-only | Software architect — produces step-by-step plans with critical file lists |
+| **ccx-verification** | read-only | Adversarial verifier — VERDICT protocol (PASS/FAIL/PARTIAL), runs real commands, catches self-rationalizations |
+| **ccx-general-purpose** | read-write | Multi-strategy worker for tasks outside other specialists |
+| **ccx-coordinator** | orchestrator | Decomposes complex work into Research, Synthesis, Implementation, Verification across parallel workers |
+
+### Safety Hooks
+
+| Hook | Trigger | Behavior |
+|------|---------|----------|
+| **Risk Guard** | `tool.execute.before` | Warns on `rm -rf`, `git push --force`, `DROP TABLE`, and other irreversible commands |
+| **Verification Reminder** | `tool.execute.after` | Nudges the agent to run `ccx-verification` after N file edits |
+
+---
+
+## The Verification Agent
+
+The most opinionated part of ccx. Key design decisions:
+
+- **Execution over reading** — every check must include a `Command run` block with real terminal output. "I reviewed the code and it looks correct" is rejected.
+- **Self-rationalization awareness** — the prompt lists excuses the agent will reach for ("the code looks correct", "the tests already pass", "this would take too long") and instructs it to do the opposite.
+- **Type-specific strategies** — different verification approaches for frontend, backend, CLI, infrastructure, database migrations, refactoring, mobile, data pipelines, and more.
+- **Adversarial probes required** — before issuing PASS, at least one probe must be attempted: concurrency, boundary values, idempotency, or orphan operations.
+
+Output format:
+
+```
+VERDICT: PASS
+```
+
+or `FAIL` with reproduction steps, or `PARTIAL` with what couldn't be verified and why.
+
+---
 
-## Configure
+## Configuration
 
 Create `~/.config/opencode/ccx.json` (global) or `.opencode/ccx.json` (project-level):
 
@@ -73,59 +145,53 @@ Create `~/.config/opencode/ccx.json` (global) or `.opencode/ccx.json` (project-l
 
 | Field | Type | Default | Description |
 |-------|------|---------|-------------|
-| `enabled` | boolean | `true` | Master toggle |
-| `disabled_sections` | string[] | `[]` | System prompt sections to skip (e.g., `["tone-style", "output-efficiency"]`) |
-| `disabled_hooks` | string[] | `[]` | Hooks to disable (e.g., `["risk-guard"]`) |
-| `output_style` | string \| null | `null` | Custom output style name |
-| `verification.auto_remind` | boolean | `true` | Nudge verification after file edits |
-| `verification.min_file_edits` | number | `3` | Edit threshold before nudge |
-
-## How It Works
-
-ccx hooks into OpenCode's plugin lifecycle at two points:
-
-**1. `config` hook** — Injects the `ccx` primary agent (with full system prompt) and 5 subagents into `config.agent`. The primary agent's prompt is composed from 7 independent sections + subagent orchestration guidance.
-
-**2. `tool.execute.before/after` hooks** — Risk Guard scans commands for destructive patterns pre-execution; Verification Reminder tracks file edit count post-execution.
-
-### System Prompt Sections
-
-The primary agent's system prompt is assembled from these composable sections:
+| `enabled` | `boolean` | `true` | Master toggle for the entire plugin |
+| `disabled_sections` | `string[]` | `[]` | Prompt sections to skip (e.g., `["tone-style"]`) |
+| `disabled_hooks` | `string[]` | `[]` | Hooks to disable (e.g., `["risk-guard"]`) |
+| `output_style` | `string \| null` | `null` | Custom output style name |
+| `verification.auto_remind` | `boolean` | `true` | Auto-nudge verification after edits |
+| `verification.min_file_edits` | `number` | `3` | File edit threshold before nudge |
 
-| Section | Purpose |
-|---------|---------|
-| `intro` | Agent identity and trust boundary |
-| `system-rules` | Permission model, context compression, prompt injection awareness |
-| `doing-tasks` | Coding discipline — scope control, minimal abstraction, honest reporting |
-| `actions` | Risk classification for reversible vs irreversible operations |
-| `using-tools` | Prefer dedicated tools over Bash, parallel tool call strategy |
-| `tone-style` | No emojis, concise output, code reference formatting |
-| `output-efficiency` | Lead with answers, skip filler, milestone-based updates |
-
-### Verification Agent
-
-The verification agent is the most opinionated component. Key behaviors:
-
-- **Runs commands, not reads code** — every check must include a `Command run` block with actual terminal output
-- **Catches its own rationalizations** — the prompt explicitly lists excuses the agent will reach for ("the code looks correct", "the tests already pass") and instructs it to do the opposite
-- **Adapts by change type** — different verification strategies for frontend, backend, CLI, infrastructure, database migrations, refactoring, etc.
-- **Requires adversarial probes** — at least one concurrency, boundary value, or idempotency test before issuing PASS
+---
 
 ## Project Structure
 
 ```
 ccx/
 ├── src/
-│   ├── index.ts                  # Plugin entry point
-│   ├── prompts/                  # 7 system prompt sections + compose + environment
-│   ├── agents/                   # 5 subagent definitions (explore, plan, verification, coordinator, general-purpose)
-│   ├── hooks/                    # config-handler, risk-guard, verification-reminder, environment-context, system-prompt-injector
-│   ├── config/                   # Zod schema + JSONC config loader
-│   └── plugin/                   # OpenCode plugin interface + tool registry
+│   ├── index.ts              # Plugin entry — composes everything
+│   ├── prompts/              # 7 system prompt sections + composer + environment detector
+│   ├── agents/               # 5 subagent definitions with tailored prompts
+│   ├── hooks/                # config-handler, risk-guard, verification-reminder
+│   ├── config/               # Zod schema + JSONC config loader
+│   └── plugin/               # OpenCode plugin interface + agent tool registry
+├── .github/workflows/
+│   └── publish.yml           # Auto-publish to npm on tag push
 ├── package.json
 └── tsconfig.json
 ```
 
+---
+
+## Contributing
+
+```bash
+git clone https://github.com/Rejudge-F/ccx.git
+cd ccx
+bun install
+bun run typecheck    # type check
+bun run build        # build to dist/
+```
+
+To publish a new version:
+
+```bash
+# bump version in package.json, then:
+git add -A && git commit -m "chore: bump to x.y.z"
+git tag vx.y.z && git push origin main --tags
+# GitHub Actions auto-publishes to npm
+```
+
 ## License
 
 MIT

package/dist/hooks/chat-message.d.ts

@@ -0,0 +1,21 @@
+import type { OhMyCCAgentConfig } from "../config/schema";
+type ChatMessageInput = {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+};
+type ChatMessageOutput = {
+    message: Record<string, unknown>;
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+};
+export declare function recordToolCall(sessionID: string, tool: string, file?: string): void;
+export declare function createChatMessageHook(config: OhMyCCAgentConfig): (input: ChatMessageInput, output: ChatMessageOutput) => Promise<void>;
+export {};

package/dist/hooks/chat-params.d.ts

@@ -0,0 +1,18 @@
+type ChatParamsInput = {
+    sessionID: string;
+    agent: string;
+    model: {
+        modelID?: string;
+        [key: string]: unknown;
+    };
+    provider: unknown;
+    message: unknown;
+};
+type ChatParamsOutput = {
+    temperature: number;
+    topP: number;
+    topK: number;
+    options: Record<string, unknown>;
+};
+export declare function createChatParamsHook(): (input: ChatParamsInput, output: ChatParamsOutput) => Promise<void>;
+export {};

package/dist/hooks/compaction.d.ts

@@ -0,0 +1,6 @@
+export declare function createCompactionHook(): (input: {
+    sessionID: string;
+}, output: {
+    context: string[];
+    prompt?: string;
+}) => Promise<void>;

package/dist/hooks/dynamic-system-prompt.d.ts

@@ -0,0 +1,9 @@
+import type { OhMyCCAgentConfig } from "../config/schema";
+export declare function trackFileEdit(sessionID: string, filePath: string): void;
+export declare function markVerificationTriggered(sessionID: string): void;
+export declare function createDynamicSystemPrompt(config: OhMyCCAgentConfig, directory: string): (input: {
+    sessionID?: string;
+    model: unknown;
+}, output: {
+    system: string[];
+}) => Promise<void>;

package/dist/hooks/message-transform.d.ts

@@ -0,0 +1,16 @@
+type MessageInfo = {
+    info: {
+        role: string;
+        [key: string]: unknown;
+    };
+    parts: Array<{
+        type: string;
+        text?: string;
+        output?: string;
+        [key: string]: unknown;
+    }>;
+};
+export declare function createMessageTransformHook(): (_input: Record<string, unknown>, output: {
+    messages: MessageInfo[];
+}) => Promise<void>;
+export {};

package/dist/hooks/tool-definition.d.ts

@@ -0,0 +1,6 @@
+export declare function createToolDefinitionHook(): (input: {
+    toolID: string;
+}, output: {
+    description: string;
+    parameters: unknown;
+}) => Promise<void>;

package/dist/index.js

@@ -1,12 +1,16 @@
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -13634,6 +13638,141 @@ function loadConfig(directory) {
   return readConfigFile(projectConfigPath) ?? readConfigFile(userConfigPath) ?? defaults;
 }
 
+// src/hooks/dynamic-system-prompt.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var sessionStates = new Map;
+function getState(sessionID) {
+  const existing = sessionStates.get(sessionID);
+  if (existing)
+    return existing;
+  const state = {
+    editedFiles: new Set,
+    verificationTriggered: false,
+    turnCount: 0
+  };
+  sessionStates.set(sessionID, state);
+  return state;
+}
+function trackFileEdit(sessionID, filePath) {
+  getState(sessionID).editedFiles.add(filePath);
+}
+function loadProjectInstructions(directory) {
+  const candidates = ["CLAUDE.md", ".claude/instructions.md", "AGENTS.md"];
+  for (const name of candidates) {
+    const fullPath = join2(directory, name);
+    if (existsSync2(fullPath)) {
+      try {
+        const content = readFileSync2(fullPath, "utf-8").trim();
+        if (content)
+          return content;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+function createDynamicSystemPrompt(config2, directory) {
+  const projectInstructions = loadProjectInstructions(directory);
+  return async (input, output) => {
+    if (!config2.enabled)
+      return;
+    const sessionID = input.sessionID;
+    if (projectInstructions) {
+      output.system.push(`# Project Instructions
+
+The following instructions were found in the project root and MUST be followed:
+
+${projectInstructions}`);
+    }
+    if (sessionID) {
+      const state = getState(sessionID);
+      state.turnCount++;
+      if (state.editedFiles.size > 0) {
+        const fileList = [...state.editedFiles].slice(-20).join(", ");
+        output.system.push(`# Session Context
+
+Files edited in this session (${state.editedFiles.size} total): ${fileList}`);
+      }
+      if (config2.verification.auto_remind && state.editedFiles.size >= config2.verification.min_file_edits && !state.verificationTriggered) {
+        output.system.push(`# Verification Reminder
+
+You have edited ${state.editedFiles.size} files in this session. You MUST run verification (via ccx-verification subagent) before declaring the task complete. This is not optional.`);
+      }
+    }
+  };
+}
+
+// src/hooks/chat-message.ts
+var EDIT_TOOLS = new Set(["edit", "write"]);
+var recentToolCalls = new Map;
+function recordToolCall(sessionID, tool, file2) {
+  const calls = recentToolCalls.get(sessionID) ?? [];
+  calls.push({ tool, file: file2 });
+  if (calls.length > 50)
+    calls.shift();
+  recentToolCalls.set(sessionID, calls);
+}
+function createChatMessageHook(config2) {
+  return async (input, output) => {
+    if (!config2.enabled)
+      return;
+    const { sessionID, agent } = input;
+    if (!sessionID)
+      return;
+    const calls = recentToolCalls.get(sessionID);
+    if (calls && calls.length > 0) {
+      const editedInRecent = calls.filter((c) => EDIT_TOOLS.has(c.tool) && c.file).map((c) => c.file);
+      for (const file2 of editedInRecent) {
+        trackFileEdit(sessionID, file2);
+      }
+    }
+    if (agent && !agent.startsWith("ccx"))
+      return;
+    const reminders = [];
+    if (config2.verification.auto_remind && calls && calls.filter((c) => EDIT_TOOLS.has(c.tool)).length >= config2.verification.min_file_edits) {
+      reminders.push(`<system-reminder>You have made file edits. Remember the verification contract: run ccx-verification before declaring completion if you have 3+ file edits, backend/API changes, or infrastructure changes.</system-reminder>`);
+    }
+    if (reminders.length > 0) {
+      output.parts.push({
+        type: "text",
+        text: reminders.join(`
+`)
+      });
+    }
+  };
+}
+
+// src/hooks/chat-params.ts
+var AGENT_PARAMS = {
+  "ccx-plan": { temperature: 0.3, topP: 0.9 },
+  "ccx-verification": { temperature: 0.2, topP: 0.85 },
+  "ccx-explore": { temperature: 0.5, topP: 0.95 },
+  "ccx-coordinator": { temperature: 0.4, topP: 0.9 },
+  "ccx-general-purpose": { temperature: 0.5, topP: 0.95 }
+};
+function createChatParamsHook() {
+  return async (input, output) => {
+    const agentParams = AGENT_PARAMS[input.agent];
+    if (!agentParams)
+      return;
+    if (agentParams.temperature !== undefined)
+      output.temperature = agentParams.temperature;
+    if (agentParams.topP !== undefined)
+      output.topP = agentParams.topP;
+    if (agentParams.topK !== undefined)
+      output.topK = agentParams.topK;
+  };
+}
+
+// src/hooks/compaction.ts
+function createCompactionHook() {
+  return async (input, output) => {
+    output.context.push("IMPORTANT: When summarizing this conversation, you MUST preserve the following:", "1. The original user task/request and any refinements", "2. The implementation plan if one was created", "3. All file paths that were edited, created, or deleted", "4. The current verification status (PASS/FAIL/PARTIAL) if verification was run", "5. Any unresolved issues, blockers, or pending decisions", "6. Key architectural decisions and their rationale", "7. The names of any subagents that were dispatched and their outcomes", "Do NOT summarize tool outputs verbatim \u2014 capture only the conclusions and any error messages.");
+  };
+}
+
 // src/prompts/actions.ts
 function getActionsSection() {
   return `# Executing actions with care
@@ -13688,8 +13827,8 @@ function getDoingTasksSection() {
 }
 
 // src/prompts/environment.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 import { type as osType, release as osRelease } from "os";
 function normalizeShell(shell) {
   if (shell.includes("zsh"))
@@ -13715,7 +13854,7 @@ function getOsVersion() {
 }
 function detectGit(cwd) {
   try {
-    return existsSync2(join2(cwd, ".git"));
+    return existsSync3(join3(cwd, ".git"));
   } catch {
     return false;
   }
@@ -14348,8 +14487,8 @@ function createConfigHook(config2, directory) {
 }
 
 // src/hooks/environment-context.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 var environmentBySession = new Map;
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -14367,7 +14506,7 @@ function createEnvironmentContext(directory) {
     const sessionID = typeof event.sessionID === "string" ? event.sessionID : typeof event.sessionId === "string" ? event.sessionId : undefined;
     const environment = {
       cwd: directory,
-      isGit: existsSync3(join3(directory, ".git")),
+      isGit: existsSync4(join4(directory, ".git")),
       platform: process.platform,
       shell: process.env.SHELL ?? "unknown"
     };
@@ -14380,6 +14519,51 @@ function createEnvironmentContext(directory) {
   };
 }
 
+// src/hooks/message-transform.ts
+var MAX_TOOL_OUTPUT_LENGTH = 8000;
+var TOOL_OUTPUT_TRIM_TO = 4000;
+function trimLongToolOutputs(messages) {
+  for (const msg of messages) {
+    if (msg.info.role !== "assistant")
+      continue;
+    for (const part of msg.parts) {
+      if (part.type !== "tool")
+        continue;
+      const output = typeof part.output === "string" ? part.output : undefined;
+      if (output && output.length > MAX_TOOL_OUTPUT_LENGTH) {
+        const head = output.slice(0, TOOL_OUTPUT_TRIM_TO / 2);
+        const tail = output.slice(-TOOL_OUTPUT_TRIM_TO / 2);
+        const trimmed = output.length - TOOL_OUTPUT_TRIM_TO;
+        part.output = `${head}
+
+... [${trimmed} characters trimmed] ...
+
+${tail}`;
+      }
+    }
+  }
+}
+function collapseConsecutiveReasoningParts(messages) {
+  for (const msg of messages) {
+    if (msg.info.role !== "assistant")
+      continue;
+    const collapsed = [];
+    for (const part of msg.parts) {
+      if (part.type === "reasoning" && collapsed.length > 0 && collapsed[collapsed.length - 1].type === "reasoning") {
+        continue;
+      }
+      collapsed.push(part);
+    }
+    msg.parts = collapsed;
+  }
+}
+function createMessageTransformHook() {
+  return async (_input, output) => {
+    trimLongToolOutputs(output.messages);
+    collapseConsecutiveReasoningParts(output.messages);
+  };
+}
+
 // src/hooks/risk-guard.ts
 var RISK_PATTERNS = [
   /rm\s+-rf\b/i,
@@ -14427,6 +14611,35 @@ function createRiskGuard() {
   };
 }
 
+// src/hooks/tool-definition.ts
+var TOOL_SAFETY_HINTS = {
+  bash: "SAFETY: Before executing, verify the command is non-destructive. Never run rm -rf, git push --force, git reset --hard, DROP TABLE, or TRUNCATE TABLE without explicit user approval. Prefer --dry-run flags when available. Quote all file paths containing spaces.",
+  edit: "SAFETY: Always read the file first before editing. Preserve existing indentation. Do not modify files you have not examined. Never edit .env files or credentials.",
+  write: "SAFETY: Prefer editing existing files over creating new ones. Never write to .env or credential files. Avoid creating files in the workspace root unless they are permanent source code."
+};
+var TOOL_CONTEXT_HINTS = {
+  glob: "Use this for finding files by name pattern. Prefer this over bash find commands.",
+  grep: "Use this for searching file contents by regex. Prefer this over bash grep/rg commands.",
+  read: "Use this for reading file contents. Prefer this over bash cat/head/tail commands."
+};
+function createToolDefinitionHook() {
+  return async (input, output) => {
+    const toolName = input.toolID.toLowerCase();
+    const safetyHint = TOOL_SAFETY_HINTS[toolName];
+    if (safetyHint) {
+      output.description = `${output.description}
+
+${safetyHint}`;
+    }
+    const contextHint = TOOL_CONTEXT_HINTS[toolName];
+    if (contextHint) {
+      output.description = `${output.description}
+
+${contextHint}`;
+    }
+  };
+}
+
 // src/hooks/verification-reminder.ts
 var sessionStateById = new Map;
 var EDIT_TOOL_NAMES = new Set(["edit", "write"]);
@@ -26848,14 +27061,35 @@ function createPluginInterface(args) {
   const riskGuard = createRiskGuard();
   const verificationReminder = createVerificationReminder(config3);
   const environmentContext = createEnvironmentContext(ctx.directory);
+  const dynamicSystemPrompt = createDynamicSystemPrompt(config3, ctx.directory);
+  const chatMessageHook = createChatMessageHook(config3);
+  const chatParamsHook = createChatParamsHook();
+  const compactionHook = createCompactionHook();
+  const toolDefinitionHook = createToolDefinitionHook();
+  const messageTransformHook = createMessageTransformHook();
   return {
     config: configHook,
     tool: createAgentTools(),
     "tool.execute.before": riskGuard,
-    "tool.execute.after": verificationReminder,
+    "tool.execute.after": async (input, output) => {
+      await verificationReminder(input, output);
+      const sessionID = typeof input.sessionID === "string" ? input.sessionID : undefined;
+      const tool3 = typeof input.tool === "string" ? input.tool.toLowerCase() : undefined;
+      if (sessionID && tool3) {
+        const args2 = input.args;
+        const file3 = typeof args2?.filePath === "string" ? args2.filePath : typeof args2?.path === "string" ? args2.path : undefined;
+        recordToolCall(sessionID, tool3, file3);
+      }
+    },
     event: async (input) => {
       await environmentContext(input, {});
-    }
+    },
+    "chat.message": chatMessageHook,
+    "chat.params": chatParamsHook,
+    "tool.definition": toolDefinitionHook,
+    "experimental.chat.system.transform": dynamicSystemPrompt,
+    "experimental.chat.messages.transform": messageTransformHook,
+    "experimental.session.compacting": compactionHook
   };
 }
 

package/dist/plugin/interface.d.ts

@@ -2,7 +2,7 @@ import type { Plugin } from "@opencode-ai/plugin";
 import type { OhMyCCAgentConfig } from "../config/schema";
 type PluginContext = Parameters<Plugin>[0];
 type PluginInstance = Awaited<ReturnType<Plugin>>;
-export type PluginInterface = Pick<PluginInstance, "config" | "tool" | "tool.execute.before" | "tool.execute.after" | "event">;
+export type PluginInterface = Pick<PluginInstance, "config" | "tool" | "tool.execute.before" | "tool.execute.after" | "event" | "chat.message" | "chat.params" | "tool.definition" | "experimental.chat.system.transform" | "experimental.chat.messages.transform" | "experimental.session.compacting">;
 export declare function createPluginInterface(args: {
     ctx: PluginContext;
     config: OhMyCCAgentConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccx-agent/opencode-ccx",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "Production-grade prompt engineering for OpenCode — disciplined coding, risk-aware actions, adversarial verification",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,6 +20,10 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run clean && bun run build"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rejudge-F/ccx.git"
+  },
   "keywords": [
     "opencode",
     "plugin",