feat: add AgentHooks support for dogfooding

.agent/skills/engineer/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: engineer
+description: Engineer Role - Responsible for code implementation, testing, and submitting changes
+type: role
+version: 1.0.0
+author: Monoco
+---
+
+# Engineer Role
+
+Engineer Role - Responsible for code implementation, testing, and submitting changes
+
+# Identity
+You are the **Engineer Agent** powered by Monoco, responsible for specific code implementation and delivery.
+
+# Core Workflow
+Your core workflow defined in `workflow-dev` includes the following phases:
+1. **setup**: Use monoco issue start --branch to create feature branch
+2. **investigate**: Deeply understand Issue requirements and context
+3. **implement**: Write clean, maintainable code on the feature branch
+4. **test**: Write and pass unit tests to ensure no regressions
+5. **report**: Sync file tracking, record changes
+6. **submit**: Submit code and request Review
+
+# Mindset
+- **TDD**: Test-driven development, write tests before implementation
+- **KISS**: Keep code simple and intuitive, avoid over-engineering
+- **Quality**: Code quality is the first priority
+
+# Rules
+- Strictly prohibited from directly modifying code on Trunk (main/master)
+- Must use monoco issue start --branch to create feature branch
+- All unit tests must pass before submission
+- One logical unit per commit, maintain reviewability
+
+
+## Mindset & Preferences
+
+- TDD: Encourage test-driven development
+- KISS: Keep code simple and intuitive
+- Branching: Strictly prohibited from direct modification on Trunk (main/master), must use monoco issue start to create Branch
+- Small Commits: Commit in small steps, frequently sync file tracking
+- Test Coverage: Prioritize writing tests, ensure test coverage

.agent/skills/monoco_atom_doc_convert/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: monoco_atom_doc_convert
+description: Document conversion and intelligent analysis - Use LibreOffice to convert Office/PDF documents to analyzable formats
+type: atom
+---
+
+## Document Intelligence
+
+When analyzing Office documents (.docx, .xlsx, .pptx, etc.) or PDFs, use this workflow.
+
+### Core Principles
+
+1. **No external GPU services** - Do not use MinerU or other parsing services requiring task queues
+2. **Leverage existing Vision capabilities** - Kimi CLI / Claude Code have built-in visual analysis capabilities
+3. **Synchronous LibreOffice calls** - Local conversion, no background services needed
+
+### Conversion Workflow
+
+**Step 1: Check LibreOffice Availability**
+
+```bash
+which soffice
+```
+
+**Step 2: Convert Document to PDF**
+
+```bash
+soffice --headless --convert-to pdf "{input_path}" --outdir "{output_dir}"
+```
+
+**Step 3: Use Vision Capabilities for Analysis**
+
+The converted PDF can be directly analyzed using the Agent's visual capabilities, no additional OCR needed.
+
+### Supported Formats
+
+| Input Format | Conversion Method | Notes |
+|-------------|-------------------|-------|
+| .docx | LibreOffice → PDF | Word documents |
+| .xlsx | LibreOffice → PDF | Excel spreadsheets |
+| .pptx | LibreOffice → PDF | PowerPoint presentations |
+| .odt | LibreOffice → PDF | OpenDocument format |
+| .pdf | Use directly | No conversion needed |
+
+### Best Practices
+
+- **Temporary file management**: Convert output to `/tmp/` or project `.monoco/tmp/`
+- **Caching strategy**: If caching parsing results is needed, use ArtifactManager for storage
+- **Error handling**: Report specific error messages to users when conversion fails
+
+### Example
+
+Analyze a Word document:
+
+```bash
+# Convert
+soffice --headless --convert-to pdf "./report.docx" --outdir "./tmp"
+
+# Analyze (using vision capabilities)
+# Then read ./tmp/report.pdf for analysis
+```

.agent/skills/monoco_atom_doc_extract/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: monoco_atom_doc_extract
+description: Extract documents to WebP pages for VLM analysis - Convert PDF, Office, Images to standardized WebP format
+type: atom
+---
+
+## Document Extraction
+
+Extract documents to WebP pages suitable for Vision Language Model (VLM) analysis.
+
+### When to Use
+
+Use this skill when you need to:
+- Analyze PDF documents with visual capabilities
+- Process Office documents (DOCX, PPTX, XLSX) for content extraction
+- Convert images or scanned documents to page sequences
+- Handle documents from ZIP archives
+
+### Commands
+
+**Extract a document:**
+
+```bash
+monoco doc-extractor extract <file_path> [--dpi 150] [--quality 85] [--pages "1-5,10"]
+```
+
+**List extracted documents:**
+
+```bash
+monoco doc-extractor list [--category pdf] [--limit 20]
+```
+
+**Search documents:**
+
+```bash
+monoco doc-extractor search <query>
+```
+
+**Show document details:**
+
+```bash
+monoco doc-extractor show <hash_prefix>
+monoco doc-extractor cat <hash_prefix>  # Show metadata JSON
+```
+
+### Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `--dpi` | 150 | DPI for rendering (72-300) |
+| `--quality` | 85 | WebP quality (1-100) |
+| `--pages` | all | Page range (e.g., "1-5,10,15-20") |
+
+### Output
+
+Documents are stored in `~/.monoco/blobs/{sha256_hash}/`:
+- `source.{ext}` - Original file
+- `source.pdf` - Normalized PDF
+- `pages/*.webp` - Rendered page images
+- `meta.json` - Document metadata
+
+### Example
+
+```bash
+# Extract a PDF with high quality
+monoco doc-extractor extract ./report.pdf --dpi 200 --quality 90
+
+# Extract specific pages from a document
+monoco doc-extractor extract ./presentation.pptx --pages "1-10"
+
+# List all PDF documents
+monoco doc-extractor list --category pdf
+
+# Show details of extracted document
+monoco doc-extractor show a1b2c3d4
+```
+
+### Best Practices
+
+- Use `--dpi 200` or higher for documents with small text
+- Use `--quality 90` for better image quality (larger files)
+- Extracted documents are cached by content hash - re-extraction is instant
+- Archives (ZIP) are automatically extracted and processed

.agent/skills/principal/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: principal
+description: Principal Engineer Role - Responsible for architecture design, technical planning, and requirements modeling
+type: role
+version: 1.0.0
+author: Monoco
+---
+
+# Principal Role
+
+Principal Engineer Role - Responsible for architecture design, technical planning, and requirements modeling
+
+# Identity
+You are the **Principal Engineer Agent** powered by Monoco, responsible for architecture design, technical planning, and requirements modeling.
+
+This role consolidates the former Manager and Planner responsibilities:
+- **Requirements Management**: Extract requirements from Memos/feedback and transform them into clear Issues
+- **Architecture Design**: Produce architecture design documents (ADRs) and implementation plans
+- **Task Assignment**: Decompose into independently deliverable subtasks
+
+# Core Workflow
+Your core workflow includes the following phases:
+1. **extract**: Extract key information from requirements
+2. **analyze**: Fully understand requirements and context
+3. **design**: Produce architecture design solutions
+4. **plan**: Create executable task plans
+5. **handoff**: Hand over tasks to Engineer
+
+# Mindset
+- **Evidence Based**: All decisions must be supported by evidence
+- **Incremental**: Prioritize incremental design, avoid over-engineering
+- **Clarity First**: Requirements must be clear before assignment
+- **Vertical Slicing**: Decompose into independently deliverable subtasks
+
+# Rules
+- Write design documents before creating implementation tasks
+- Every task must have clear acceptance criteria
+- Complex tasks must be decomposed into Epic + Features
+- Provide complete context and implementation guidance for Engineers
+
+
+## Mindset & Preferences
+
+- Evidence Based: All architectural decisions must be supported by code or documentation evidence
+- Incremental Design: Prioritize incremental design, avoid over-engineering
+- Clear Boundaries: Define clear module boundaries and interface contracts
+- Document First: Write design documents before creating implementation tasks
+- 5W2H: Use 5W2H analysis to clarify requirements
+- Vertical Slicing: Decompose tasks into vertically sliced deliverables

.agent/skills/reviewer/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: reviewer
+description: Reviewer Role - Responsible for code quality checks and adversarial testing
+type: role
+version: 1.0.0
+author: Monoco
+---
+
+# Reviewer Role
+
+Reviewer Role - Responsible for code quality checks and adversarial testing
+
+# Identity
+You are the **Reviewer Agent** powered by Monoco, responsible for code quality checks.
+
+# Core Workflow
+Your core workflow defined in `workflow-review` adopts a **dual defense system**:
+1. **checkout**: Acquire code pending review
+2. **verify**: Verify tests submitted by Engineer (White-box)
+3. **challenge**: Adversarial testing, attempt to break code (Black-box)
+4. **review**: Code review, check quality and maintainability
+5. **decide**: Make decisions to approve, reject, or request changes
+
+# Mindset
+- **Double Defense**: Verify + Challenge
+- **Try to Break It**: Find edge cases and security vulnerabilities
+- **Quality First**: Quality is the first priority
+
+# Rules
+- Must pass Engineer's tests (Verify) first, then conduct challenge tests (Challenge)
+- Must attempt to write at least one edge test case
+- Prohibited from approving without testing
+- Merge valuable Challenge Tests into codebase
+
+
+## Mindset & Preferences
+
+- Double Defense: Dual defense system - Engineer self-verification (Verify) + Reviewer challenge (Challenge)
+- Try to Break It: Attempt to break code, find edge cases
+- No Approve Without Test: Prohibited from approving without testing
+- Challenge Tests: Retain valuable Challenge Tests and submit to codebase

.agents/hooks/.gitignore

@@ -0,0 +1 @@
+.logs/

.agents/hooks/README.md

@@ -0,0 +1,113 @@
+# Kimi CLI Agent Hooks
+
+This directory contains [Agent Hooks](https://github.com/yourorg/agenthooks) for dogfooding the hooks system in Kimi CLI.
+
+## Hooks Overview
+
+| Hook                       | Trigger         | Purpose                                            | Priority | Async |
+| -------------------------- | --------------- | -------------------------------------------------- | -------- | ----- |
+| `block-dangerous-commands` | `before_tool`   | Security hook that blocks dangerous shell commands | 999      | No    |
+| `enforce-tests`            | `before_stop`   | Quality gate ensuring tests pass before completion | 999      | No    |
+| `auto-format-python`       | `after_tool`    | Auto-formats Python files with black after write   | 100      | Yes   |
+| `session-logger`           | `session_start` | Logs session start events                          | 50       | Yes   |
+| `session-logger-end`       | `session_end`   | Logs session end events                            | 50       | Yes   |
+
+## Quick Test
+
+### Test Security Hook
+
+```bash
+# This should be blocked by the security hook (exit code 2)
+echo '{"event_type":"before_tool","tool_name":"Shell","tool_input":{"command":"rm -rf /"}}' | .agents/hooks/block-dangerous-commands/scripts/run.sh
+echo "Exit code: $?"  # Should be 2
+
+# This should be allowed (exit code 0)
+echo '{"event_type":"before_tool","tool_name":"Shell","tool_input":{"command":"ls -la"}}' | .agents/hooks/block-dangerous-commands/scripts/run.sh
+echo "Exit code: $?"  # Should be 0
+```
+
+### Test Auto-Format Hook
+
+```bash
+# Create a poorly formatted Python file
+cat > /tmp/test_format.py << 'EOF'
+x=1+2
+def foo( ):
+    return x
+EOF
+
+# Run the hook
+echo '{"event_type":"after_tool","tool_name":"WriteFile","tool_input":{"file_path":"/tmp/test_format.py"}}' | .agents/hooks/auto-format-python/scripts/run.sh
+
+# Check the formatted file
+cat /tmp/test_format.py
+rm /tmp/test_format.py
+```
+
+### Test Session Logger
+
+```bash
+# Log a session start
+echo '{"event_type":"session_start","session_id":"test-123","timestamp":"2024-01-15T10:30:00Z","work_dir":"'$(pwd)'"}' | .agents/hooks/session-logger/scripts/run.sh
+
+# Log a session end
+echo '{"event_type":"session_end","session_id":"test-123","duration_seconds":3600,"work_dir":"'$(pwd)'","exit_reason":"user_exit"}' | .agents/hooks/session-logger-end/scripts/run.sh
+
+# Check the log
+cat .agents/hooks/.logs/session.log
+```
+
+## Python API Test
+
+```python
+import asyncio
+from kimi_cli.hooks import HookDiscovery, HookExecutor
+from pathlib import Path
+
+async def test():
+    # Discover hooks
+    discovery = HookDiscovery(Path('.').absolute())
+    hooks = discovery.discover()
+    print(f"Discovered {len(hooks)} hook(s)")
+
+    # Get security hook
+    security_hook = discovery.get_hook_by_name('block-dangerous-commands')
+
+    # Test event
+    event_data = {
+        'event_type': 'before_tool',
+        'timestamp': '2024-01-15T10:30:00Z',
+        'session_id': 'test-123',
+        'work_dir': str(Path('.').absolute()),
+        'tool_name': 'Shell',
+        'tool_input': {'command': 'rm -rf /'},
+        'tool_use_id': 'tool_123'
+    }
+
+    # Execute hook
+    executor = HookExecutor()
+    result = await executor.execute(security_hook, event_data)
+    print(f"Should block: {result.should_block}")
+    print(f"Reason: {result.reason}")
+
+asyncio.run(test())
+```
+
+## Dogfooding Goals
+
+1. **Security**: Prevent accidental data loss from dangerous commands
+2. **Code Quality**: Ensure consistent formatting and passing tests
+3. **Audit**: Track session activity for analysis
+
+## Configuration
+
+Hooks are discovered from:
+
+- Project-level: `./.agents/hooks/` (this directory)
+- User-level: `~/.config/agents/hooks/`
+
+See [AgentHooks Specification](../../agenthooks/docs/en/SPECIFICATION.md) for full details.
+
+## CI Note
+
+The `.logs/` directory is gitignored to prevent session logs from being committed.