oh-my-customcode 0.154.0 → 0.155.0

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

@@ -1,92 +1,144 @@
 ---
 name: hada-scout
-description: hada.io RSS feed monitoring for AI agent/harness articles with automated /scout analysis
-scope: package
-version: 1.0.0
-user-invocable: false
+description: hada.io RSS feed monitoring with LLM pre-scout filtering for oh-my-customcode relevance
+scope: core
+version: 2.0.0
+user-invocable: true
+argument-hint: "[--limit N] [--threshold N]"
 ---
 
 # hada-scout
 
-Automated pipeline that monitors hada.io (via feedburner RSS) for AI agent, harness, benchmark, and eval-related articles, then runs `/scout` analysis on each match.
+3-phase in-session pipeline that monitors hada.io (via feedburner RSS) for relevant articles,
+uses a haiku LLM batch to pre-score relevance, and dispatches full `/scout` analysis only on
+high-scoring candidates.
 
 ## Purpose
 
-Complement geeknews-scout with harness/eval-focused coverage from hada.io. While geeknews-scout casts a broad net over AI agent news, hada-scout narrows to benchmark/evaluation framework content — the domain most relevant to oh-my-customcode's harness and agent-eval subsystems.
+Replace the v1.0 keyword-regex approach with context-aware LLM pre-scoring. Haiku evaluates
+all feed titles in a single batch call, reducing false positives from ~30-40% to ~5-10% and
+eliminating the external CronJob dependency for user-invoked runs.
 
-## Architecture: 2-Layer Hybrid
+## Architecture: 3-Phase In-Session Pipeline
 
-### Layer 1 — check-feed.sh (feed → issues)
+### Phase 1 — Fetch & Parse
 
-1. Fetch hada.io feedburner RSS
-2. Filter entries by keyword regex (case-insensitive)
-3. Dedup against existing `hada-scout` issues
-4. Create GitHub issue per match with labels `hada-scout` + `pending-scout`
+1. WebFetch the hada.io RSS feed (`https://feeds.feedburner.com/geeknews-feed`)
+2. Parse all items: title, URL, publication date
+3. Default: latest 50 items (configurable via `--limit` or `HADA_SCOUT_LIMIT`)
 
-### Layer 2 — scout-runner.sh (issues → /scout)
+### Phase 2 — Pre-Scout (haiku batch)
 
-1. Find open issues with `pending-scout` label
-2. Extract source URL from issue body
-3. Run `claude -p "/scout {url}"` (max 5 executions per run)
-4. Parse verdict from /scout output
-5. Apply verdict label, remove `pending-scout`
+1. Spawn 1 haiku agent with ALL item titles as a single batch input
+2. Agent evaluates each title against oh-my-customcode's domain (see prompt template below)
+3. Returns relevance score (0–100) and a 1-line reason for each item
+4. Threshold: ≥ 60 passes to Phase 3 (configurable via `--threshold` or `HADA_SCOUT_THRESHOLD`)
+5. Cost: ~$0.01–0.05 for 50 items
 
-## Keyword Strategy
+### Phase 3 — Scout Dispatch
 
-hada-scout uses harness/benchmark/eval focused keywords, distinct from geeknews-scout's broader AI agent coverage:
+1. Dedup: check existing `hada-scout` labeled issues via `gh issue list --label hada-scout`
+2. For each passing item (max 5 per run, configurable via `MAX_SCOUT_PER_RUN`):
+   - Run full `/scout` analysis via Skill tool invocation
+   - Scout creates GitHub issue with verdict label on `baekenough/oh-my-customcode`
+   - Add `hada-scout` label to the created issue
+3. Dispatch up to 4 scouts in parallel per R009
+
+## Pre-Scout Prompt Template
+
+The haiku agent receives the following system prompt:
 
 ```
-harness|benchmark|eval|evaluation framework|agent framework|코드 리뷰 자동화|하네스|벤치마크|평가
+You are a relevance filter for the oh-my-customcode project — an AI agent harness/orchestration
+system built on Claude Code CLI with 44 agents, 74 skills.
+
+Project domains (HIGH relevance):
+- AI agent orchestration, multi-agent systems, agent design patterns
+- Harness, benchmark, evaluation frameworks for AI agents
+- Claude Code, Anthropic ecosystem, MCP protocol
+- Code review automation, development workflow automation
+- Agent sandbox, isolation, security patterns
+- LLM-assisted development tools and methodologies
+
+Project domains (MEDIUM relevance):
+- General AI/ML tooling that could be adapted for agent workflows
+- DevOps automation patterns applicable to agent infrastructure
+- New programming paradigms for AI-assisted development
+
+NOT relevant:
+- Pure frontend/UI frameworks without agent connection
+- Business/management topics
+- Hardware, networking, non-AI infrastructure
+- Social media, marketing tools
+
+For each item below, return: score (0-100) | reason (1 line)
+
+Items:
+{numbered_item_list}
 ```
 
-Geeknews-scout handles: `Claude|Anthropic|MCP|AI agent|에이전트|agentic|multi-agent|...`
+## Display Format
+
+```
+[hada-scout] Scanning hada.io feed...
+├── Phase 1: Fetched {n} items
+├── Phase 2: Pre-scout → {passed}/{total} items passed (threshold: {t}%)
+│   ├── ✓ {title1} (score: {s1}%)
+│   ├── ✓ {title2} (score: {s2}%)
+│   └── ✗ {title3} (score: {s3}%) — skipped
+├── Phase 3: Scout dispatch ({n} items, max 5)
+│   ├── [1] /scout {url1} → {verdict}
+│   └── [2] /scout {url2} → {verdict}
+└── [Done] {created}/{dispatched} issues created
+```
 
 ## Label Scheme
 
 | Label | Purpose |
 |-------|---------|
 | `hada-scout` | Source identification — all hada-scout created issues |
-| `pending-scout` | Awaiting /scout analysis (set by Layer 1, cleared by Layer 2) |
 | `scout:internalize` | /scout verdict: adopt into project |
 | `scout:integrate` | /scout verdict: use as external dependency |
 | `scout:skip` | /scout verdict: not relevant |
 
 ## Cost Controls
 
-- Layer 2 runs at most **5 /scout executions per cron invocation**
-- Each /scout call costs ~$0.5–1.5 (sonnet)
-- Remaining `pending-scout` issues are processed in the next scheduled run
-
-## Deployment
-
-- Pattern: same K8s CronJob structure as `infra/geeknews-scout/`
-- Host: `ubuntu-ext` cluster
-- Infrastructure files: `infra/hada-scout/`
-  - `check-feed.sh` — Layer 1 feed poller
-  - `scout-runner.sh` — Layer 2 /scout executor
-  - `Dockerfile`
-  - `cronjob.template.yaml`
-  - `deploy.sh`
-  - `.env.example`
+| Stage | Model | Estimated Cost |
+|-------|-------|----------------|
+| Pre-scout (Phase 2) | haiku | ~$0.01–0.05 per run (50 items) |
+| Full scout (Phase 3) | sonnet | ~$0.5–1.5 per item, max 5 per run |
+| Total max per invocation | — | ~$8 |
 
 ## Environment Variables
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `GH_TOKEN` | (required) | GitHub PAT for issue creation |
-| `REPO` | `baekenough/oh-my-customcode` | Target repo |
-| `FEED_URL` | `http://feeds.feedburner.com/geeknews-feed` | hada.io RSS feed |
-| `KEYWORDS` | (see above) | Pipe-separated keyword regex |
-| `MAX_SCOUT_PER_RUN` | `5` | Max /scout executions per Layer 2 run |
+| `FEED_URL` | `https://feeds.feedburner.com/geeknews-feed` | RSS feed URL |
+| `HADA_SCOUT_THRESHOLD` | `60` | Pre-scout score threshold (0–100) |
+| `HADA_SCOUT_LIMIT` | `50` | Max feed items to fetch and score |
+| `MAX_SCOUT_PER_RUN` | `5` | Max /scout executions per invocation |
+| `GH_TOKEN` | (required) | GitHub PAT for issue creation and dedup |
 
 ## Integration
 
 | Rule | How |
 |------|-----|
-| R009 | Layer 1 and Layer 2 run as independent CronJobs |
-| R010 | Skill defines the architecture; implementation delegated to infra-docker-expert for K8s manifests |
-| scout skill | Layer 2 invokes `/scout` via `claude -p` subprocess |
-
-## Tracking Issue
+| R009 | Phase 3 scout dispatches run in parallel (up to 4 concurrent) |
+| R010 | Orchestrator manages phases; analysis delegated to haiku/sonnet agents |
+| R015 | Pre-scout scores and reasons displayed before dispatching full scouts |
+| scout skill | Phase 3 invokes `/scout` via Skill tool for each candidate URL |
+
+## Differences from v1.0
+
+| Aspect | v1.0 (keyword) | v2.0 (LLM pre-scout) |
+|--------|----------------|----------------------|
+| Filtering | Regex keyword match | LLM relevance scoring (haiku) |
+| Invocation | External CronJob only | User-invocable `/hada-scout` + CronJob |
+| Precision | Low (keyword false positives) | High (context-aware scoring) |
+| Cost per scan | $0 (regex) + $2.5–7.5 (/scout) | $0.05 (pre-scout) + $2.5–7.5 (/scout) |
+| False positive rate | ~30–40% | ~5–10% |
+| Scope | `package` | `core` |
+
+## Tracking
 
 GitHub Issue #841

package/templates/.claude/skills/memory-management/SKILL.md

@@ -194,3 +194,47 @@ recall_errors:
   - Connection failure: Return empty with warning
   - Invalid query: Help user reformulate
 ```
+
+## MemKraft Bridge (Optional)
+
+> External integration: [MemKraft](https://github.com/seojoonkim/memkraft) — zero-dependency compound memory for AI agents.
+> Install: `pipx install memkraft`
+
+### When to Use
+
+| Capability | claude-mem | MemKraft |
+|-----------|-----------|----------|
+| Session persistence | ✅ (Chroma) | ✅ (Markdown) |
+| Entity tracking | ❌ | ✅ (person/org/concept) |
+| Source attribution | ❌ | ✅ (`[Source: who, when, how]`) |
+| Auto-maintenance | ❌ | ✅ (Dream Cycle) |
+| CJK entity extraction | ❌ | ✅ (Korean/Chinese/Japanese) |
+| Offline search | ❌ | ✅ (stdlib difflib) |
+
+Use MemKraft when entity tracking or source attribution is needed. Use claude-mem for simple session persistence.
+
+### Commands
+
+```bash
+# Extract entities from a document
+memkraft extract <file>
+
+# Get a brief on a topic
+memkraft brief <topic>
+
+# Run maintenance cycle (dedup, prune orphans)
+memkraft dream
+```
+
+### Integration with sys-memory-keeper
+
+At session end, sys-memory-keeper can optionally run MemKraft operations:
+
+1. `memkraft extract` on session summary → builds entity graph
+2. `memkraft dream` → prunes stale entries (run weekly, not every session)
+
+### Prerequisites
+
+- Python 3.9+
+- `pipx install memkraft`
+- No API keys required (offline-only)

package/templates/.claude/skills/omcustom-auto-improve/SKILL.md

@@ -66,8 +66,8 @@ Map each approved item to the appropriate subagent by `targetType`:
 | targetType | Agent | Action |
 |------------|-------|--------|
 | agent | mgr-creator | Modify agent frontmatter/body |
-| skill | Matching domain expert | Revise skill SKILL.md |
-| routing | general-purpose | Update routing patterns |
+| skill | mgr-creator | Revise skill SKILL.md (R010 Protected Paths) |
+| routing | mgr-creator | Update routing patterns (R010 Protected Paths) |
 | model-escalation | general-purpose | Update model field in agent frontmatter |
 
 Spawn agents in parallel (max 4 per R009). Each agent receives:

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

@@ -63,6 +63,8 @@ Execute these steps to display available pipelines:
    - **Skill steps** (`skill: name`): Invoke via Skill tool — `Skill(skill: "{name}")`
    - **Prompt steps** (`prompt: text`): Execute the described action using appropriate agents/tools
    - **Foreach steps** (`foreach: collection`): Iterate over collection from previous step output
+   - **Parallel steps** (`parallel: [step1, step2]`): Execute contained steps concurrently using Agent tool. Each parallel step runs as an independent Agent. Max 4 concurrent per R009. Steps within a parallel block MUST be independent (no shared state, no sequential dependencies). Dependencies between parallel and non-parallel steps use `depends_on:` field.
+   - **Agent mode**: When spawning agents via Agent tool, always pass `mode: "bypassPermissions"` to match agent frontmatter. The Agent tool default (`acceptEdits`) overrides frontmatter `permissionMode`, causing permission prompts during unattended execution.
 5. Report completion or failure
 
 ### Resume Mode (/pipeline resume)
@@ -94,6 +96,48 @@ Track per-step state:
 
 State saved to `/tmp/.claude-pipeline-{name}-{PPID}.json` on failure.
 
+## Parallel Execution
+
+Pipeline steps can be grouped for parallel execution:
+
+```yaml
+steps:
+  - name: phase-1
+    parallel:
+      - name: task-a
+        skill: skill-a
+        description: First independent task
+      - name: task-b
+        skill: skill-b
+        description: Second independent task
+  - name: phase-2
+    skill: next-step
+    depends_on: phase-1
+```
+
+### Parallel Rules
+
+- Max 4 concurrent steps per parallel block (R009 hard cap)
+- Steps within a parallel block MUST be independent
+- `depends_on` enforces ordering between blocks
+- Each parallel step is spawned as a separate Agent tool call in the SAME message
+- If any parallel step fails with `error: halt-and-report`, all remaining steps in the block are cancelled
+- State tracking records each parallel step individually
+
+### Parallel State Format
+
+```json
+{
+  "name": "phase-1",
+  "type": "parallel",
+  "status": "running",
+  "children": [
+    {"name": "task-a", "status": "completed", "duration_ms": 5000},
+    {"name": "task-b", "status": "running"}
+  ]
+}
+```
+
 ## Error Handling
 
 - Pipeline not found → list available pipelines with suggestion

package/templates/.claude/skills/post-release-followup/SKILL.md

@@ -10,7 +10,7 @@ effort: medium
 
 ## Purpose
 
-After PR creation in the auto-dev release workflow, collect unaddressed findings and present actionable follow-up recommendations. The user chooses: execute now, register as issues, or skip.
+After PR creation in the auto-dev release workflow, collect unaddressed findings and present actionable follow-up recommendations. Genuine defects and process gaps are registered as GitHub issues automatically (no user confirmation needed). Only code-changing "immediate action" items require user confirmation.
 
 ## Workflow
 
@@ -63,55 +63,73 @@ Remove duplicates (same issue referenced from multiple sources). Categorize:
 | **이슈 등록** | P3 이슈, LOW 검증 발견사항, 새 TODO, Medium PR 리뷰 발견사항 | 이슈로 등록 |
 | **참고** | 이미 추적 중인 이슈, 외관 관련 메모 | 건너뛰기 |
 
+### Auto-Register Genuine Defects (no-ask)
+
+**Before presenting the summary to the user**, auto-register all "이슈 등록" category items that are genuine defects or process gaps. No user confirmation is required for these.
+
+**Definition — auto-register if ANY of:**
+- Genuine defect: a bug, regression, broken behavior, or incorrect output observed during verification
+- Process gap: a workflow hole, missing guard, or coverage gap surfaced by deep-verify / triage
+- Coverage gap: a missing test, missing documentation, or missing automation for a known scenario
+
+**Definition — do NOT auto-register (keep for user choice):**
+- Pure cosmetic / style preference notes
+- Items that are purely subjective or opinion-based
+
+**When ambiguous, lean toward registering.** Registering a borderline item costs nothing; missing a genuine defect costs a future session.
+
+**How to auto-register:**
+```bash
+gh issue create \
+  --title "{간결한 설명}" \
+  --body "## 출처\n\nv{version} 릴리즈 워크플로우에서 자동 등록.\n\n## 컨텍스트\n\n{상세 컨텍스트}\n\n## 권장 조치\n\n{권장 사항}" \
+  --label "professor"
+```
+Add priority label (`P3` default for defects surfaced here; escalate to `P2` if MEDIUM+ severity).
+
+**Authority**: user directive (session 102) — genuine defects found during release workflows should be registered without prompting. See also R016 Defect Response Matrix: CI/infra defect and Process gap both require Issue registration.
+
+After auto-registering, include the created issue numbers in the summary display.
+
 ### 3. Present to User
 
-Display follow-up summary:
+Auto-register all genuine defects first (see above). Then display follow-up summary showing what was already registered and what remains for user decision:
 
 ```
 [Follow-up] {n}개 후속 작업 발견
 
+━━━ 자동 등록 완료 ({count}개) ━━━
+  ✓ #{issue_number} — {description} (이미 등록됨)
+  ✓ #{issue_number} — {description} (이미 등록됨)
+
 ━━━ 즉시 실행 추천 ({count}개) ━━━
   1. {description} — 출처: {source}
   2. {description} — 출처: {source}
 
-━━━ 이슈 등록 추천 ({count}개) ━━━
-  3. {description} — 출처: {source}
-  4. {description} — 출처: {source}
-
 ━━━ 참고 사항 ({count}개) ━━━
-  5. {description} — 이미 #{issue_number}로 추적 중
-
-선택:
-  [A] 추천대로 실행 (즉시 실행 + 이슈 등록)
-  [B] 모두 즉시 실행
-  [C] 모두 이슈 등록
-  [D] 개별 선택 (항목별로 질문)
-  [E] 건너뛰기
+  3. {description} — 이미 #{issue_number}로 추적 중
+
+즉시 실행 항목 선택:
+  [A] 추천대로 실행 (즉시 실행 항목 모두 실행)
+  [B] 개별 선택 (항목별로 질문)
+  [C] 건너뛰기
 ```
 
-Use AskUserQuestion (or equivalent user prompt) to get the choice.
+Use AskUserQuestion (or equivalent user prompt) to get the choice **only if there are "즉시 실행" items**. If there are none, skip the prompt and complete automatically.
 
 ### 4. Process User Choice
 
 **Option A (추천대로)**:
 - "Immediate" items → delegate to appropriate specialist agents for execution
-- "Trackable" items → create GitHub issues via `gh issue create`
+- (Trackable items were already auto-registered in step above)
 - "Informational" items → skip
 
-**Option B (모두 즉시 실행)**:
-- All Immediate + Trackable items → delegate to specialist agents
-- Follow implementation patterns from the release workflow
-
-**Option C (모두 이슈 등록)**:
-- All Immediate + Trackable items → `gh issue create` with appropriate labels
-- Label: `professor` for auto-triage in next workflow run
-
-**Option D (개별 선택)**:
-- For each item, ask: `[{n}] {description} — 실행(E) / 이슈(I) / 건너뛰기(S)?`
+**Option B (개별 선택)**:
+- For each "즉시 실행" item, ask: `[{n}] {description} — 실행(E) / 건너뛰기(S)?`
 - Process each per user choice
 
-**Option E (건너뛰기)**:
-- Skip all follow-up actions
+**Option C (건너뛰기)**:
+- Skip remaining immediate actions
 - Complete workflow
 
 ### 5. Report
@@ -126,7 +144,16 @@ Use AskUserQuestion (or equivalent user prompt) to get the choice.
 
 ## Issue Creation Template
 
-When creating follow-up issues:
+For auto-registered genuine defects / process gaps:
+
+```bash
+gh issue create \
+  --title "{간결한 설명}" \
+  --body "## 출처\n\nv{version} 릴리즈 워크플로우에서 자동 등록.\n\n## 컨텍스트\n\n{triage/verify에서의 상세 컨텍스트}\n\n## 권장 조치\n\n{권장 사항}" \
+  --label "professor"
+```
+
+For user-requested issue creation (Option C fallback, if ever used):
 
 ```bash
 gh issue create \
@@ -135,12 +162,13 @@ gh issue create \
   --label "professor"
 ```
 
-Add priority label (`P1`, `P2`, `P3`) based on categorization.
+Add priority label (`P1`, `P2`, `P3`) based on categorization. Default for auto-registered items: `P3` (escalate to `P2` for MEDIUM+ severity).
 
 ## Notes
 
 - This skill runs in the main conversation context (via workflow skill step)
-- User interaction is expected — this is NOT a fully automated step
+- Genuine defect/process gap items are auto-registered as issues WITHOUT user confirmation (session 102 directive)
+- Only "즉시 실행" (code-changing immediate action) items require user confirmation
 - All file modifications delegated to specialist subagents per R010
 - Issue creation uses `gh` CLI directly (read-only operation pattern)
 - If no follow-up candidates found, report "No follow-up actions needed" and complete

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

@@ -22,17 +22,8 @@ Switch the active plugin set to match a workflow profile, reducing per-spawn ski
 
 ## Implementation rules
 
-> **MANDATORY — .claude/ path bypass (R010)**
-> ALL writes to `.claude/` paths MUST go through a `/tmp/*.sh` script via Bash.
-> Direct `Write(".claude/...")` or `Edit(".claude/...")` triggers user approval prompts
-> that block automation regardless of `bypassPermissions` mode.
->
-> Pattern:
-> 1. Write tool → `/tmp/profile-{op}-$$.sh` with heredoc targeting `.claude/`
-> 2. Bash tool → `bash /tmp/profile-{op}-$$.sh`
->
-> This applies to `.claude/profiles/.active` and `~/.claude/settings.json` writes.
-> Reference: R010 (MUST-orchestrator-coordination.md), #1046, #1052, #1062.
+> **.claude/ path handling (CC v2.1.121+)**
+> Direct Write/Edit on `.claude/profiles/.active` and `~/.claude/settings.json` is permitted under `mode: "bypassPermissions"` (CC v2.1.121+, #1101). The legacy `/tmp/*.sh` bypass is deprecated. For CC < v2.1.121, see git history for the legacy pattern.
 
 ## Profiles directory
 

package/templates/.claude/skills/reasoning-sandwich/SKILL.md

@@ -35,6 +35,7 @@ A model allocation pattern that wraps implementation actions with stronger-model
 | Phase | Recommended Model | Rationale |
 |-------|------------------|-----------|
 | Pre-reasoning (analyze/plan) | opus | Complex architectural reasoning, edge case detection |
+| Pre-reasoning (Opus 4.7) | opus47 | Opus 4.7 makes fewer tool calls and reasons more deeply; pre-reasoning phase should include explicit tool batch planning |
 | Action (implement/generate) | sonnet | Optimized for code generation, balanced cost |
 | Post-verification (review/test) | sonnet or haiku | Structural verification, checklist validation |
 
@@ -62,3 +63,23 @@ This pattern is used by:
 | Opus for everything | Wasteful, slow | Reserve opus for reasoning-heavy phases |
 | Haiku for planning | Insufficient depth | Use opus for complex analysis |
 | Skipping verification | False completion risk | Always include post-verification phase |
+| Forcing frequent tool calls on Opus 4.7 | Fights model's natural reasoning-first tendency | Let Opus 4.7 reason; batch tool calls in pre-reasoning |
+
+## Opus 4.7 Considerations
+
+Opus 4.7 exhibits a distinct behavioral pattern: fewer tool calls with deeper reasoning per call. This affects how the sandwich pattern is applied:
+
+| Aspect | Opus 4.6 | Opus 4.7 |
+|--------|----------|----------|
+| Tool call frequency | Moderate | Lower |
+| Reasoning depth per call | Standard | Deeper |
+| Pre-reasoning benefit | Plan what to check | Plan explicit tool batch — model will under-call if not guided |
+
+### Pre-reasoning Adjustment for Opus 4.7
+
+When using Opus 4.7 in the pre-reasoning phase:
+1. **Explicitly enumerate tools needed** — Opus 4.7 may skip tool calls it deems unnecessary
+2. **Batch tool-call plans upfront** — structure the action phase with a concrete tool sequence
+3. **Prefer fewer, richer tool calls** — align with the model's natural tendency
+
+Reference: [Best practices for using Claude Opus 4.7 with Claude Code](https://claude.com/blog/best-practices-for-using-claude-opus-4-7-with-claude-code)

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

@@ -58,13 +58,13 @@ 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
+├── Phase 1: 콘텐츠 수집 및 요약
+├── Phase 2: 프로젝트 철학 로드
+├── Phase 3: 적합성 분석 (sonnet)
+└── Phase 4: 이슈 생성
 
-Estimated: ~1 min | Cost: ~$0.5-1.5
-Execute? [Y/n]
+예상: ~1분 | 비용: ~$0.5-1.5
+실행하시겠습니까? [Y/n]
 ```
 
 ## Workflow
@@ -90,7 +90,7 @@ Execute? [Y/n]
 
 ### Phase 3: Fit Analysis
 
-Spawn 1 sonnet agent with the following analysis prompt.
+Spawn 1 sonnet agent with `mode: "bypassPermissions"` and the following analysis prompt.
 
 **Inputs**:
 - Fetched content summary (Phase 1)
@@ -133,6 +133,7 @@ Return a structured verdict:
 - philosophy_table: criterion/fit/rationale for each dimension
 - recommendation: specific integration plan or skip reason
 - next_steps: 2-3 actionable items
+- IMPORTANT: Write all analysis output in Korean. Technical terms, code references, label names, and skill/agent names stay in English.
 - escalation: true/false (INTERNALIZE + M/L effort = true)
 ```
 
@@ -163,32 +164,32 @@ gh issue close {number} -c "Auto-closed: scout verdict is SKIP"
 ### Issue Body Template
 
 ```markdown
-## Scout Report: {title}
+## Scout 리포트: {title}
 
-**Source**: {url}
-**Verdict**: {INTERNALIZE / INTEGRATE / SKIP}
-**Priority**: {P1 / P2 / P3}
+**출처**: {url}
+**판정**: {INTERNALIZE / INTEGRATE / SKIP}
+**우선순위**: {P1 / P2 / P3}
 
-## Summary
-{2-3 sentence summary of the external content}
+## 요약
+{외부 콘텐츠에 대한 2-3문장 요약}
 
-## 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} |
+## 프로젝트 철학 정합성
+| 기준 | 적합 | 근거 |
+|------|------|------|
+| Compilation metaphor | {check/cross} | {설명} |
+| Separation of concerns (R006) | {check/cross} | {설명} |
+| Dynamic agent creation | {check/cross} | {설명} |
+| 기존 스킬 중복 | {check/cross} | {중복 스킬 목록} |
 
-## Recommendation
-{Specific integration plan — which skill/agent/guide to create, or why to skip}
+## 권장 사항
+{구체적 통합 계획 — 어떤 skill/agent/guide를 생성할지, 또는 건너뛰는 이유}
 
-## Next Steps
-- [ ] {follow-up action 1}
-- [ ] {follow-up action 2}
+## 다음 단계
+- [ ] {후속 조치 1}
+- [ ] {후속 조치 2}
 
 ---
-Generated by `/scout`
+`/scout`에 의해 생성됨
 ```
 
 ## Escalation
@@ -196,18 +197,18 @@ Generated by `/scout`
 When verdict is `INTERNALIZE` and integration effort is M or L:
 
 ```
-[Advisory] Deep analysis recommended.
-└── Consider running: /research {url}
+[Advisory] 심층 분석 권장.
+└── 실행 검토: /research {url}
 ```
 
 ## Result Display
 
 ```
-[Scout Complete] {title}
-├── Verdict: {INTERNALIZE / INTEGRATE / SKIP}
-├── Priority: {P1 / P2 / P3}
-├── Issue: #{number}
-└── Escalation: {/research recommended | none}
+[Scout 완료] {title}
+├── 판정: {INTERNALIZE / INTEGRATE / SKIP}
+├── 우선순위: {P1 / P2 / P3}
+├── 이슈: #{number}
+└── 에스컬레이션: {/research 권장 | 없음}
 ```
 
 ## Model Selection

package/templates/.claude/skills/skills-sh-search/SKILL.md

@@ -43,15 +43,16 @@ Search the [skills.sh](https://skills.sh/) marketplace for reusable AI agent ski
    ├── Verify installation in .claude/skills/
    └── Check installed SKILL.md frontmatter
 
-4. Post-install adaptation
-   ├── Review installed SKILL.md frontmatter
-   ├── Add oh-my-customcode fields if missing:
-   │   ├── user-invocable: true|false
-   │   ├── model-invocable (if not present)
-   │   └── argument-hint (if applicable)
-   └── Add source metadata:
-       ├── source-type: skills-sh
-       └── source-origin: <owner/repo>
+4. Post-install adaptation (delegate to mgr-creator per R010 Protected Paths)
+   ├── Delegate SKILL.md frontmatter adaptation to mgr-creator:
+   │   ├── Add oh-my-customcode fields if missing:
+   │   │   ├── user-invocable: true|false
+   │   │   ├── model-invocable (if not present)
+   │   │   └── argument-hint (if applicable)
+   │   └── Add source metadata:
+   │       ├── source-type: skills-sh
+   │       └── source-origin: <owner/repo>
+   └── mgr-creator validates R006 frontmatter compliance
 
 5. Ontology sync
    ├── Notify: run "omcustom ontology build" to register new skill