chore(rules): Clean up redundant docs and add markitdown permissions

- Remove thinking.md (built-in Claude Code behavior)
- Remove "Claude Code Integration" section from commit-style.md
- Add markitdown bash permissions to settings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.claude/settings.local.json

@@ -83,7 +83,10 @@
       "Bash(opencode run \"What is 2+2? One word.\")",
       "Bash(opencode auth:*)",
       "Bash(opencode models:*)",
-      "Bash(opencode run:*)"
+      "Bash(opencode run:*)",
+      "Bash(markitdown --help:*)",
+      "Bash(where markitdown:*)",
+      "Bash(markitdown:*)"
     ],
     "deny": [],
     "ask": [

rules/commit-style.md

@@ -98,18 +98,3 @@ BAD:  "feat(agents): Add the new docker expert agent for containerization"
 GOOD: "feat(agents): Add docker-expert agent"
 ```
 
-## Claude Code Integration
-
-When committing via Claude Code, these patterns apply:
-
-1. Analyze staged changes to determine appropriate type
-2. Infer scope from modified directories
-3. Generate concise, imperative subject line
-4. Add body for non-trivial changes explaining rationale
-5. Append standard footer:
-
-```
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
-
-Co-Authored-By: Claude <model> <noreply@anthropic.com>
-```

rules/thinking.md

@@ -1,74 +0,0 @@
-# Extended Thinking
-
-Claude Code supports extended thinking mode for deeper analysis. Trigger with these phrases:
-
-## Thinking Triggers
-
-| Phrase | Budget | Use When |
-|--------|--------|----------|
-| `think` | Low | Quick analysis, simple decisions |
-| `think hard` | Medium | Multiple options to evaluate |
-| `think harder` | High | Complex problems, architectural decisions |
-| `ultrathink` | Maximum | Critical decisions, security review |
-
-## Usage Examples
-
-```
-"think about how to structure this feature"
-"think hard about the trade-offs here"
-"think harder about potential edge cases"
-"ultrathink about the security implications"
-```
-
-## When to Use Each Level
-
-### `think` - Quick Analysis
-- Choosing between 2-3 simple options
-- Reviewing straightforward code
-- Making minor decisions
-
-### `think hard` - Deeper Analysis
-- Planning a new feature
-- Evaluating multiple approaches
-- Debugging non-obvious issues
-
-### `think harder` - Comprehensive Evaluation
-- Architectural decisions
-- Complex refactoring plans
-- Performance optimization strategies
-- Trade-off analysis with many variables
-
-### `ultrathink` - Maximum Depth
-- Security-critical code review
-- Production incident investigation
-- Major architectural changes
-- Risk assessment for breaking changes
-
-## Best Practices
-
-1. **Use during planning** - Think before implementing
-2. **Match complexity** - Don't ultrathink simple tasks
-3. **Combine with subagents** - "think harder, then use subagents to verify"
-4. **Be specific** - "think hard about the authentication flow" > "think hard"
-
-## Example Workflow
-
-```
-1. "Read the authentication module"
-2. "think harder about how to add OAuth support"
-3. [Claude provides detailed analysis]
-4. "Now implement it following the plan"
-```
-
-## Anti-Patterns
-
-```
-BAD:  "ultrathink about this typo fix"
-GOOD: "fix the typo in line 42"
-
-BAD:  "think" (with no context)
-GOOD: "think about the best data structure for this use case"
-
-BAD:  Jumping straight to implementation
-GOOD: "think hard about the approach, then implement"
-```