oh-my-customcodex 0.1.0

package/templates/.claude/skills/scout/SKILL.md

@@ -0,0 +1,250 @@
+---
+name: scout
+description: Analyze external URL to evaluate fit with oh-my-customcodex project and auto-create GitHub issue with verdict
+scope: core
+version: 1.0.0
+user-invocable: true
+argument-hint: "<url>"
+---
+
+# /scout — External Link Analysis
+
+Analyze an external URL (tech blog, tool, library, methodology) to evaluate its fit with the oh-my-customcodex project and auto-create a GitHub issue with a structured verdict.
+
+## Usage
+
+```
+/scout <url>
+/scout https://news.hada.io/topic?id=27673
+/scout https://github.com/user/repo
+```
+
+## Verdict Taxonomy
+
+| Verdict | Meaning | Label | Follow-up |
+|---------|---------|-------|-----------|
+| **INTERNALIZE** | Aligns with project philosophy; should become a skill/agent/guide | `scout:internalize` + `P1`/`P2`/`P3` | `/research` or direct implementation |
+| **INTEGRATE** | Useful but best kept as external dependency | `scout:integrate` + `P2`/`P3` | Plugin/MCP integration review |
+| **SKIP** | Irrelevant or duplicates existing functionality | `scout:skip` | Issue created then closed |
+
+## Pre-flight Guards
+
+### Guard 1: URL Validity (GATE)
+
+Before any work, validate the URL:
+
+```bash
+# Check URL is syntactically valid
+echo "$URL" | grep -qE '^https?://'
+```
+
+If invalid: `[Pre-flight] GATE: Invalid or unreachable URL. Please check and retry.` — abort.
+
+### Guard 2: Duplicate Scout (WARN)
+
+Search existing GitHub issues for prior scout reports on the same URL domain:
+
+```bash
+DOMAIN=$(echo "$URL" | sed 's|https\?://||' | cut -d'/' -f1)
+gh issue list --state all --label "scout:internalize,scout:integrate,scout:skip" \
+  --json number,title,body --jq ".[] | select(.body | contains(\"$DOMAIN\"))" 2>/dev/null
+```
+
+If found: `[Pre-flight] WARN: Similar URL already scouted in issue #N. Proceed anyway? [Y/n]`
+
+## Display Format
+
+Before execution, show the plan:
+
+```
+[Scout] {url}
+├── Phase 1: Fetch & Summarize
+├── Phase 2: Load Project Philosophy
+├── Phase 3: Fit Analysis (sonnet)
+└── Phase 4: Issue Creation
+
+Estimated: ~1 min | Cost: ~$0.5-1.5
+Execute? [Y/n]
+```
+
+## Workflow
+
+### Phase 1: Fetch & Summarize
+
+1. `WebFetch(url)` — retrieve page content
+2. Extract core information:
+   - Title and purpose
+   - Key technology / methodology
+   - Approach and principles
+3. If fetch fails — report error, abort
+
+### Phase 2: Load Project Philosophy
+
+1. `Read(AGENTS.md)` — extract architecture philosophy:
+   - Compilation metaphor (source -> build -> artifact)
+   - Separation of concerns (R006)
+   - Dynamic agent creation ("no expert? create one")
+   - Skill/agent/guide/rule structure
+2. `Read(README.md)` — extract project overview and component inventory
+3. `Glob(.codex/skills/*/SKILL.md)` — list existing skills for overlap detection
+
+### Phase 3: Fit Analysis
+
+Spawn 1 sonnet agent with the following analysis prompt.
+
+> **Permission Mode**: When spawning the analysis agent, pass `mode: "bypassPermissions"` in the Agent tool call if the session uses bypassPermissions. Without explicit mode, CC defaults to `acceptEdits`.
+
+**Inputs**:
+- Fetched content summary (Phase 1)
+- Project philosophy context (Phase 2)
+- Existing skill list (Phase 2)
+
+**Analysis dimensions**:
+
+| Dimension | Question |
+|-----------|----------|
+| Philosophy alignment | Does it match the compilation metaphor, separation of concerns, "create experts on demand"? |
+| Technical fit | Does it complement or overlap with existing skills/agents/guides? |
+| Integration effort | How much work to internalize vs. use externally? |
+| Value proposition | What concrete benefit does it bring to the project? |
+
+**Agent prompt template**:
+
+```
+You are a project fit analyst. Given:
+
+1. External content summary:
+{phase1_summary}
+
+2. Project philosophy:
+{phase2_philosophy}
+
+3. Existing skills ({skill_count} total):
+{skill_list}
+
+Analyze the external content against the project philosophy across 4 dimensions:
+- Philosophy alignment
+- Technical fit (overlap with existing skills?)
+- Integration effort (XS/S/M/L)
+- Value proposition
+
+Return a structured verdict:
+- verdict: INTERNALIZE | INTEGRATE | SKIP
+- priority: P1 | P2 | P3
+- rationale: 2-3 sentences
+- philosophy_table: criterion/fit/rationale for each dimension
+- recommendation: specific integration plan or skip reason
+- next_steps: 2-3 actionable items
+- escalation: true/false (INTERNALIZE + M/L effort = true)
+```
+
+**Output**: Structured verdict with rationale.
+
+### Phase 4: Issue Creation
+
+1. Ensure scout labels exist (defensive, idempotent):
+```bash
+gh label create "scout:internalize" --color "0E8A16" --description "Scout: should be internalized" 2>/dev/null || true
+gh label create "scout:integrate" --color "1D76DB" --description "Scout: keep as external" 2>/dev/null || true
+gh label create "scout:skip" --color "D4C5F9" --description "Scout: skip" 2>/dev/null || true
+```
+
+2. Create GitHub issue:
+```bash
+gh issue create \
+  --title "[scout:{verdict}] {content_title}" \
+  --label "scout:{verdict},P{n}" \
+  --body "{issue_body}"
+```
+
+3. If verdict is `SKIP`: auto-close the issue:
+```bash
+gh issue close {number} -c "Auto-closed: scout verdict is SKIP"
+```
+
+### Issue Body Template
+
+```markdown
+## Scout Report: {title}
+
+**Source**: {url}
+**Verdict**: {INTERNALIZE / INTEGRATE / SKIP}
+**Priority**: {P1 / P2 / P3}
+
+## Summary
+{2-3 sentence summary of the external content}
+
+## Philosophy Alignment
+| Criterion | Fit | Rationale |
+|-----------|-----|-----------|
+| Compilation metaphor | {check/cross} | {explanation} |
+| Separation of concerns (R006) | {check/cross} | {explanation} |
+| Dynamic agent creation | {check/cross} | {explanation} |
+| Existing skill overlap | {check/cross} | {overlapping skills list} |
+
+## Recommendation
+{Specific integration plan — which skill/agent/guide to create, or why to skip}
+
+## Next Steps
+- [ ] {follow-up action 1}
+- [ ] {follow-up action 2}
+
+---
+Generated by `/scout`
+```
+
+## Escalation
+
+When verdict is `INTERNALIZE` and integration effort is M or L:
+
+```
+[Advisory] Deep analysis recommended.
+└── Consider running: /research {url}
+```
+
+## Result Display
+
+```
+[Scout Complete] {title}
+├── Verdict: {INTERNALIZE / INTEGRATE / SKIP}
+├── Priority: {P1 / P2 / P3}
+├── Issue: #{number}
+└── Escalation: {/research recommended | none}
+```
+
+## Model Selection
+
+| Phase | Model | Rationale |
+|-------|-------|-----------|
+| Phase 1 (Fetch) | orchestrator | Simple WebFetch, no agent needed |
+| Phase 2 (Load) | orchestrator | Simple Read/Glob, no agent needed |
+| Phase 3 (Analysis) | sonnet | Balanced reasoning for fit analysis |
+| Phase 4 (Issue) | orchestrator | gh issue create via Bash |
+
+## Integration
+
+| Rule | How |
+|------|-----|
+| R009 | Single agent in Phase 3 — no parallelism needed |
+| R010 | Orchestrator manages phases 1/2/4; analysis delegated to sonnet agent in Phase 3 |
+| R015 | Display scout plan before execution (Display Format section) |
+
+## When NOT to Use
+
+| Scenario | Better Alternative |
+|----------|--------------------|
+| Deep multi-source research | `/research <url>` |
+| Internal project analysis | `/omcodex:analysis` |
+| Known tool evaluation | Direct agent conversation |
+| Bulk URL analysis (5+) | `/research` with URL list |
+
+## Differences from /research
+
+| Aspect | /scout | /research |
+|--------|--------|-----------|
+| Purpose | Quick fit evaluation | Deep multi-dimensional analysis |
+| Teams | 1 agent | 10 teams |
+| Cost | ~$0.5-1.5 | ~$8-15 |
+| Duration | 1-2 min | 10-20 min |
+| Output | Issue with verdict | Full report with ADOPT/ADAPT/AVOID |
+| When | First contact with new link | Deep dive after scout recommends |

package/templates/.claude/skills/sdd/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: sdd
+description: Alias for sdd-dev — Spec-Driven Development workflow
+scope: core
+version: 1.0.0
+user-invocable: true
+argument-hint: "[task description or leave empty for guided workflow]"
+---
+
+# SDD Skill (Alias)
+
+This is an alias for the `sdd-dev` skill.
+
+**Redirects to**: `.codex/skills/sdd-dev/SKILL.md`
+
+See [sdd-dev](../sdd-dev/SKILL.md) for full documentation.
+
+## Usage
+
+```
+/sdd [task description]
+```
+
+Equivalent to `/sdd-dev [task description]`.

package/templates/.claude/skills/sdd-dev/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: sdd-dev
+description: Spec-Driven Development workflow — enforces sdd/ folder hierarchy with planning-first gates, current-state artifacts, and completion verification
+scope: core
+version: 1.0.0
+user-invocable: true
+argument-hint: "[task description or leave empty for guided workflow]"
+---
+
+# SDD (Spec-Driven Development) Skill
+
+Spec-Driven Development workflow that enforces the `sdd/` folder hierarchy. All development work proceeds through planning-first gates and produces current-state artifacts as completion evidence.
+
+## Trigger Keywords
+
+Invoke this skill when user requests:
+- 개발해, 작업해, 구현해, 수정해, 고쳐, 리팩토링해, 테스트해, 배포해
+- 화면명세서, 화면설계서, UI, 디자인, screen spec, screen design
+- develop, implement, fix, refactor, build, deploy
+
+## sdd/ Folder Hierarchy
+
+```
+sdd/
+├── 01_planning/     # Requirements, constraints, stakeholder input
+├── 02_plan/         # Execution plan, acceptance criteria, approach
+├── 03_build/        # Current build state, implementation notes
+├── 04_verify/       # Verification evidence, test results, residual risks
+├── 05_operate/      # Deployment notes, runbooks (conditional)
+└── 99_toolchain/    # Tool configs, scripts, environment setup
+```
+
+**Key Principle**: These folders are **current-state artifacts**, not history archives. Each file reflects the current state of the work — update in place rather than appending new versions.
+
+## Workflow
+
+### Step 0: Activation Check
+
+Verify `sdd/` folder exists in the project root:
+
+```bash
+ls sdd/ 2>/dev/null || echo "sdd/ folder not found"
+```
+
+If `sdd/` does not exist:
+1. Inform the user that SDD workflow requires a `sdd/` folder
+2. Offer to create the folder structure: `mkdir -p sdd/{01_planning,02_plan,03_build,04_verify,05_operate,99_toolchain}`
+3. Ask user to confirm before proceeding
+
+If `sdd/` exists, continue to Step 1.
+
+### Step 1: Planning Review (Gate)
+
+**MUST complete before any coding begins.**
+
+Read all relevant planning documents:
+
+```
+[SDD] Reading planning documents...
+├── sdd/01_planning/ — requirements, constraints
+└── sdd/99_toolchain/ — tool configs, environment
+```
+
+Actions:
+1. Read `sdd/01_planning/` contents (all .md files)
+2. Read `sdd/99_toolchain/` if present
+3. Identify: What is the task? What constraints exist? What is in scope?
+4. If planning docs are empty or missing, prompt user to fill them before proceeding
+
+**Gate**: If planning docs are absent or insufficient, pause and ask user to provide requirements. Do NOT proceed to plan phase without understanding the context.
+
+### Step 2: Plan Phase
+
+Create or update `sdd/02_plan/` with the execution plan.
+
+Artifact to produce: `sdd/02_plan/current.md`
+
+```markdown
+# Execution Plan
+
+## Task
+{task description}
+
+## Approach
+{implementation strategy}
+
+## Acceptance Criteria
+- [ ] {criterion 1}
+- [ ] {criterion 2}
+- [ ] {criterion N}
+
+## Out of Scope
+- {what will NOT be done}
+
+## Dependencies
+- {prerequisite or dependency}
+```
+
+**Display**:
+```
+[SDD Plan] Created sdd/02_plan/current.md
+├── Approach: {one-line summary}
+├── Criteria: {N} acceptance criteria defined
+└── Gate: Plan ready — proceeding to build
+```
+
+### Step 3: Build Phase
+
+Implement the changes. Update `sdd/03_build/` with current build state.
+
+Artifact to produce or update: `sdd/03_build/current.md`
+
+```markdown
+# Build State
+
+## Status
+{In Progress | Complete}
+
+## Implemented
+- {file or component}: {what was done}
+
+## Decisions Made
+- {decision}: {rationale}
+
+## Known Issues
+- {issue}: {planned resolution}
+```
+
+During implementation:
+- Follow the plan from Step 2
+- Update `sdd/03_build/current.md` as work progresses
+- Keep the artifact current (not a log — overwrite stale entries)
+
+**Display**:
+```
+[SDD Build] Implementing changes...
+[SDD Build] Updated sdd/03_build/current.md
+└── Status: {In Progress | Complete}
+```
+
+### Step 4: Verify Phase
+
+Run verification and update `sdd/04_verify/` with evidence.
+
+Artifact to produce or update: `sdd/04_verify/current.md`
+
+```markdown
+# Verification Evidence
+
+## Acceptance Criteria Results
+- [x] {criterion 1}: {evidence}
+- [x] {criterion 2}: {evidence}
+- [ ] {criterion N}: {reason if not passing}
+
+## Tests Run
+- {test command or suite}: {result}
+
+## Residual Risks
+- {risk}: {severity} — {mitigation plan}
+
+## Verdict
+{Pass | Fail | Conditional Pass}
+```
+
+Actions:
+1. Check each acceptance criterion from `sdd/02_plan/current.md`
+2. Run applicable tests or verification commands
+3. Document evidence (do NOT just say "tests pass" — include actual output or reference)
+4. List residual risks honestly
+
+**Gate**: If verdict is Fail, return to Step 3 (Build). Do NOT declare done with a Fail verdict.
+
+**Display**:
+```
+[SDD Verify] Running verification...
+[SDD Verify] Updated sdd/04_verify/current.md
+├── Criteria: {N}/{total} passing
+├── Residual risks: {count}
+└── Verdict: {Pass | Fail | Conditional Pass}
+```
+
+### Step 5: Operate Phase (Conditional)
+
+Only execute if deployment is in scope for this task.
+
+Artifact to produce or update: `sdd/05_operate/current.md`
+
+```markdown
+# Operate State
+
+## Deployment
+- Environment: {target}
+- Method: {how deployed}
+- Timestamp: {when}
+
+## Runbook
+{steps to operate, restart, rollback}
+
+## Monitoring
+{what to watch, alerts, logs}
+```
+
+Skip this step if:
+- Task is code-only (no deployment)
+- User did not request deployment
+- Deployment is handled by CI/CD automatically
+
+### Step 6: Completion Gate
+
+Before declaring `[Done]`, verify:
+
+```
+[SDD Done?] Checking completion gates...
+├── sdd/02_plan/current.md — exists? {Y/N}
+├── sdd/03_build/current.md — exists and current? {Y/N}
+├── sdd/04_verify/current.md — exists and verdict Pass? {Y/N}
+└── sdd/05_operate/current.md — exists (if deploy in scope)? {Y/N}
+```
+
+If any gate fails, complete the missing artifact before declaring done.
+
+Final display:
+```
+[SDD Done] Task complete
+├── Plan: sdd/02_plan/current.md
+├── Build: sdd/03_build/current.md
+├── Verify: sdd/04_verify/current.md (Verdict: Pass)
+└── Artifacts are current-state — ready for next iteration
+```
+
+## Artifact Maintenance Rules
+
+1. **Overwrite, don't append**: Update files in place. These are current-state docs, not logs.
+2. **One file per folder**: `current.md` is the canonical artifact. Supplementary files are allowed but the main doc is always `current.md`.
+3. **Checkboxes reflect reality**: Do NOT pre-check criteria. Update checkboxes as work is verified.
+4. **Residual risks are honest**: List known risks even after passing. Hiding risks defeats the purpose.
+
+## Integration with Other Skills
+
+| Skill | When to Use Together |
+|-------|---------------------|
+| `/deep-plan` | Before `/sdd-dev` when requirements are ambiguous — use deep-plan to research, then sdd-dev to execute |
+| `/structured-dev-cycle` | Alternative workflow without sdd/ folder — use sdd-dev when project uses sdd/ hierarchy |
+| `/dev-review` | After Step 4 — use dev-review for additional code quality check |
+| `/adversarial-review` | After Step 4 — use adversarial-review for security-sensitive changes |
+
+## Example Usage
+
+```
+/sdd-dev add user authentication to the API
+/sdd-dev implement pagination for the product list screen
+/sdd-dev 화면명세서 기반으로 대시보드 UI 구현
+/sdd-dev refactor the payment module
+/sdd-dev  # (no argument — guided workflow)
+```
+
+When no argument is provided, ask: "어떤 작업을 진행할까요? sdd/01_planning/ 의 요구사항을 기반으로 계획을 수립합니다."

package/templates/.claude/skills/sdd-development/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: sdd-development
+description: Alias for sdd-dev — Spec-Driven Development workflow
+scope: core
+version: 1.0.0
+user-invocable: true
+argument-hint: "[task description or leave empty for guided workflow]"
+---
+
+# SDD Development Skill (Alias)
+
+This is an alias for the `sdd-dev` skill.
+
+**Redirects to**: `.codex/skills/sdd-dev/SKILL.md`
+
+See [sdd-dev](../sdd-dev/SKILL.md) for full documentation.
+
+## Usage
+
+```
+/sdd-development [task description]
+```
+
+Equivalent to `/sdd-dev [task description]`.

package/templates/.claude/skills/secretary-routing/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: secretary-routing
+description: Routes agent management tasks to the correct manager agent. Use when user requests agent creation, updates, audits, git operations, or verification.
+scope: core
+user-invocable: false
+context: fork
+---
+
+# Secretary Routing Skill
+
+## Purpose
+
+Routes agent management tasks to the appropriate manager agent. This skill contains the coordination logic for orchestrating manager agents (mgr-creator, mgr-updater, mgr-supplier, mgr-gitnerd, mgr-sauron).
+
+## Manager Agents
+
+| Agent | Purpose | Triggers |
+|-------|---------|----------|
+| mgr-creator | Create new agents | "create agent", "new agent" |
+| mgr-updater | Update external agents | "update agent", "sync" |
+| mgr-supplier | Validate dependencies | "audit", "check deps" |
+| mgr-gitnerd | Git operations | "commit", "push", "pr" |
+| mgr-sauron | R017 auto-verification | "verify", "full check" |
+| mgr-claude-code-bible | Claude Code spec compliance | "spec check", "verify compliance" |
+| sys-memory-keeper | Memory operations | "save memory", "recall", "memory search" |
+| sys-naggy | TODO management | "todo", "track tasks", "task list" |
+
+## Routing Decision (Priority Order)
+
+Before routing via Task tool, evaluate Agent Teams eligibility first:
+
+**Self-check:** Does this task need 3+ agents, shared state, or inter-agent communication? If yes, prefer Agent Teams over Task tool. See R018 for the full decision matrix.
+
+| Scenario | Preferred |
+|----------|-----------|
+| Single manager task | Task Tool |
+| Batch agent creation (3+) | Agent Teams |
+| Multi-round verification (sauron) | Task Tool |
+| Agent audit + fix cycle | Agent Teams |
+
+## Command Routing
+
+```
+User Input → Routing → Manager Agent
+
+create   → mgr-creator
+update   → mgr-updater
+audit    → mgr-supplier
+git      → mgr-gitnerd
+verify   → mgr-sauron
+spec     → mgr-claude-code-bible
+memory   → sys-memory-keeper
+todo            → sys-naggy
+improve-report  → omcodex:improve-report (skill invocation)
+auto-improve    → omcodex:auto-improve (skill invocation)
+batch           → multiple (parallel)
+```
+
+**improve-report keywords**: "improve-report", "improvement", "개선", "개선 리포트", "improve" → invoke `omcodex:improve-report` skill (read-only, no agent delegation needed)
+
+**auto-improve keywords**: "auto-improve", "자동 개선", "개선 적용", "apply improvements", "improvement suggestions" → invoke `omcodex:auto-improve` skill (worktree isolation, sauron verification, PR creation)
+
+### Ontology-RAG Enrichment (R019)
+
+If `get_agent_for_task` MCP tool is available, call it with the original query and inject `suggested_skills` into the agent prompt. Skip silently on failure.
+
+### Step 5: Soul Injection (R006)
+
+If the selected agent has `soul: true` in frontmatter, read and prepend `.codex/agents/souls/{agent-name}.soul.md` content to the prompt. Skip silently if file doesn't exist.
+
+## Routing Rules
+
+### 1. Single Task Routing
+
+```
+1. Parse user command and identify intent
+2. Select appropriate manager agent
+3. Spawn Task with selected agent role
+4. Monitor execution
+5. Report result to user
+```
+
+> **Permission Mode**: When spawning agents, pass `mode: "bypassPermissions"` in the Agent tool call if the session uses bypassPermissions. Without explicit mode, CC defaults to `acceptEdits`.
+
+### 2. Batch/Parallel Task Routing
+
+When command requires multiple independent operations:
+
+```
+1. Break down into sub-tasks
+2. Identify parallelizable tasks (max 4)
+3. Spawn parallel Task instances
+4. Aggregate results
+5. Report summary to user
+```
+
+## Sub-agent Model Selection
+
+| Agent | Recommended Model | Reason |
+|-------|-------------------|--------|
+| mgr-creator | sonnet | File generation, balanced |
+| mgr-updater | sonnet | External sync, web fetch |
+| mgr-supplier | haiku | File scan, validation |
+| mgr-gitnerd | sonnet | Commit message quality |
+| mgr-sauron | sonnet | Multi-round verification |
+| mgr-claude-code-bible | sonnet | Spec compliance checks |
+| sys-memory-keeper | sonnet | Memory operations, search |
+| sys-naggy | haiku | Simple TODO tracking |
+
+## No Match Fallback
+
+When no manager agent matches the request but the task is clearly management-related:
+
+```
+User Input → No matching manager agent
+  ↓
+Evaluate: Is this a specialized management/tooling task?
+  YES → Delegate to mgr-creator with context:
+        domain: detected tool/technology
+        type: manager
+        skills: auto-discover from .codex/skills/
+  NO  → Ask user for clarification
+```
+
+**Examples of dynamic creation triggers:**
+- New CI/CD tool management (e.g., "ArgoCD 배포 관리해줘")
+- New monitoring tool setup (e.g., "Grafana 대시보드 관리")
+- Unfamiliar package manager operations
+
+## Usage
+
+This skill is NOT user-invocable. It is automatically triggered when the main conversation detects agent management intent.