oh-my-customcode 0.49.0 → 0.51.0

package/README.md

@@ -13,7 +13,7 @@
 
 **[한국어 문서 (Korean)](./README_ko.md)**
 
-45 agents. 89 skills. 21 rules. One command.
+45 agents. 91 skills. 21 rules. One command.
 
 ```bash
 npm install -g oh-my-customcode && cd your-project && omcustom init
@@ -138,7 +138,7 @@ Each agent declares its tools, model, memory scope, and limitations in YAML fron
 
 ---
 
-### Skills (89)
+### Skills (91)
 
 | Category | Count | Includes |
 |----------|-------|----------|
@@ -274,7 +274,7 @@ your-project/
 ├── CLAUDE.md                   # Entry point
 ├── .claude/
 │   ├── agents/                 # 45 agent definitions
-│   ├── skills/                 # 89 skill modules
+│   ├── skills/                 # 91 skill modules
 │   ├── rules/                  # 21 governance rules (R000-R021)
 │   ├── hooks/                  # 15 lifecycle hook scripts
 │   ├── schemas/                # Tool input validation schemas

package/dist/cli/index.js

@@ -9323,7 +9323,7 @@ var init_package = __esm(() => {
   package_default = {
     name: "oh-my-customcode",
     workspaces: ["packages/*"],
-    version: "0.49.0",
+    version: "0.51.0",
     description: "Batteries-included agent harness for Claude Code",
     type: "module",
     bin: {
@@ -25838,6 +25838,7 @@ var MESSAGES = {
     "update.file_applied": "Applied update to {{path}}",
     "update.lockfile_regenerated": "Lockfile regenerated ({{files}} files tracked)",
     "update.lockfile_failed": "Failed to regenerate lockfile: {{error}}",
+    "update.protected_file_updated": "⟳ Protected file {{file}} in {{component}} updated: {{hint}}",
     "config.load_failed": "Failed to load config: {{error}}",
     "config.not_found": "Config not found at {{path}}, using defaults",
     "config.saved": "Config saved to {{path}}",
@@ -25882,6 +25883,7 @@ var MESSAGES = {
     "update.file_applied": "{{path}} 업데이트 적용",
     "update.lockfile_regenerated": "잠금 파일 재생성 완료 ({{files}}개 파일 추적)",
     "update.lockfile_failed": "잠금 파일 재생성 실패: {{error}}",
+    "update.protected_file_updated": "⟳ 보호 파일 {{file}} ({{component}}) 업데이트됨: {{hint}}",
     "config.load_failed": "설정 로드 실패: {{error}}",
     "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
     "config.saved": "설정 저장: {{path}}",
@@ -29933,7 +29935,7 @@ async function handleBackupIfRequested(targetDir, backup, result) {
   result.backedUpPaths.push(backupPath);
   info("update.backup_created", { path: backupPath });
 }
-async function processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config) {
+async function processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config, lockfile) {
   const componentUpdate = updateCheck.updatableComponents.find((c) => c.name === component);
   if (!componentUpdate && !options.force) {
     result.skippedComponents.push(component);
@@ -29945,7 +29947,7 @@ async function processComponentUpdate(targetDir, component, updateCheck, customi
     return;
   }
   try {
-    const preserved = await updateComponent(targetDir, component, customizations, options, config);
+    const preserved = await updateComponent(targetDir, component, customizations, options, config, lockfile);
     result.updatedComponents.push(component);
     result.preservedFiles.push(...preserved);
   } catch (err) {
@@ -29954,9 +29956,9 @@ async function processComponentUpdate(targetDir, component, updateCheck, customi
     result.skippedComponents.push(component);
   }
 }
-async function updateAllComponents(targetDir, components, updateCheck, customizations, options, result, config) {
+async function updateAllComponents(targetDir, components, updateCheck, customizations, options, result, config, lockfile) {
   for (const component of components) {
-    await processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config);
+    await processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config, lockfile);
   }
 }
 function getEntryTemplateName2(language) {
@@ -30138,8 +30140,9 @@ async function update(options) {
     const manifestCustomizations = await resolveManifestCustomizations(options, options.targetDir);
     const configPreserveFiles = resolveConfigPreserveFiles(options, config);
     const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles, options.targetDir);
+    const lockfile = await readLockfile(options.targetDir);
     const components = options.components || getAllUpdateComponents();
-    await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config);
+    await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config, lockfile);
     await runFullUpdatePostProcessing(options, result, config);
     const lockfileResult = await generateAndWriteLockfileForDir(options.targetDir);
     if (lockfileResult.warning) {
@@ -30200,15 +30203,46 @@ async function componentHasUpdate(_targetDir, component, config) {
   const latestVersion = await getLatestVersion();
   return installedVersion !== latestVersion;
 }
-async function collectProtectedSkipPaths(srcPath, destPath, componentPath, forceOverwriteAll) {
+async function shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile) {
+  if (!lockfile) {
+    return true;
+  }
+  const lockfileEntry = lockfile.files[lockfileKey];
+  if (!lockfileEntry) {
+    return false;
+  }
+  if (!await fileExists(targetFilePath)) {
+    return false;
+  }
+  try {
+    const currentHash = await computeFileHash(targetFilePath);
+    return currentHash !== lockfileEntry.templateHash;
+  } catch {
+    return true;
+  }
+}
+async function collectProtectedSkipPaths(srcPath, destPath, componentPath, forceOverwriteAll, lockfile, targetDir) {
   if (forceOverwriteAll) {
-    const warnedPaths = await findProtectedFilesInDir(srcPath, componentPath);
-    return { skipPaths: [], warnedPaths };
+    const warnedPaths2 = await findProtectedFilesInDir(srcPath, componentPath);
+    return { skipPaths: [], warnedPaths: warnedPaths2, updatedPaths: [] };
   }
   const protectedRelative = await findProtectedFilesInDir(srcPath, componentPath);
   const path3 = await import("node:path");
-  const skipPaths = protectedRelative.map((p) => path3.relative(destPath, join14(destPath, p)));
-  return { skipPaths, warnedPaths: protectedRelative };
+  const skipPaths = [];
+  const warnedPaths = [];
+  const updatedPaths = [];
+  for (const p of protectedRelative) {
+    const targetFilePath = join14(targetDir, componentPath, p);
+    const lockfileKey = `${componentPath}/${p}`.replace(/\\/g, "/");
+    const shouldSkip = await shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile);
+    if (shouldSkip) {
+      skipPaths.push(path3.relative(destPath, join14(destPath, p)));
+      warnedPaths.push(p);
+    } else {
+      updatedPaths.push(p);
+    }
+  }
+  return { skipPaths, warnedPaths, updatedPaths };
 }
 function isEntryProtected(relPath, componentRelativePrefix) {
   if (isProtectedFile(relPath)) {
@@ -30244,7 +30278,7 @@ async function findProtectedFilesInDir(dirPath, componentRelativePrefix) {
   }
   return protected_;
 }
-async function updateComponent(targetDir, component, customizations, options, config) {
+async function updateComponent(targetDir, component, customizations, options, config, lockfile) {
   const preservedFiles = [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
@@ -30261,7 +30295,11 @@ async function updateComponent(targetDir, component, customizations, options, co
       skipPaths.push(cc.path);
     }
   }
-  const { skipPaths: protectedSkipPaths, warnedPaths: protectedWarnedPaths } = await collectProtectedSkipPaths(srcPath, destPath, componentPath, !!options.forceOverwriteAll);
+  const {
+    skipPaths: protectedSkipPaths,
+    warnedPaths: protectedWarnedPaths,
+    updatedPaths: protectedUpdatedPaths
+  } = await collectProtectedSkipPaths(srcPath, destPath, componentPath, !!options.forceOverwriteAll, lockfile, targetDir);
   for (const protectedPath of protectedWarnedPaths) {
     if (options.forceOverwriteAll) {
       warn("update.protected_file_force_overwrite", {
@@ -30273,10 +30311,17 @@ async function updateComponent(targetDir, component, customizations, options, co
       warn("update.protected_file_skipped", {
         file: protectedPath,
         component,
-        hint: "File contains AI behavioral constraints and was not updated. Use --force-overwrite-all to override."
+        hint: "File was modified by user and preserved. Use --force-overwrite-all to override."
       });
     }
   }
+  for (const updatedPath of protectedUpdatedPaths) {
+    info("update.protected_file_updated", {
+      file: updatedPath,
+      component,
+      hint: "Protected file updated (unmodified by user, matches lockfile hash)."
+    });
+  }
   skipPaths.push(...protectedSkipPaths);
   const path3 = await import("node:path");
   const normalizedSkipPaths = skipPaths.map((p) => path3.relative(destPath, join14(targetDir, p)));

package/dist/index.js

@@ -376,6 +376,7 @@ var MESSAGES = {
     "update.file_applied": "Applied update to {{path}}",
     "update.lockfile_regenerated": "Lockfile regenerated ({{files}} files tracked)",
     "update.lockfile_failed": "Failed to regenerate lockfile: {{error}}",
+    "update.protected_file_updated": "⟳ Protected file {{file}} in {{component}} updated: {{hint}}",
     "config.load_failed": "Failed to load config: {{error}}",
     "config.not_found": "Config not found at {{path}}, using defaults",
     "config.saved": "Config saved to {{path}}",
@@ -420,6 +421,7 @@ var MESSAGES = {
     "update.file_applied": "{{path}} 업데이트 적용",
     "update.lockfile_regenerated": "잠금 파일 재생성 완료 ({{files}}개 파일 추적)",
     "update.lockfile_failed": "잠금 파일 재생성 실패: {{error}}",
+    "update.protected_file_updated": "⟳ 보호 파일 {{file}} ({{component}}) 업데이트됨: {{hint}}",
     "config.load_failed": "설정 로드 실패: {{error}}",
     "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
     "config.saved": "설정 저장: {{path}}",
@@ -1125,6 +1127,30 @@ function computeFileHash(filePath) {
     });
   });
 }
+async function readLockfile(targetDir) {
+  const lockfilePath = join4(targetDir, LOCKFILE_NAME);
+  const exists = await fileExists(lockfilePath);
+  if (!exists) {
+    debug("lockfile.not_found", { path: lockfilePath });
+    return null;
+  }
+  try {
+    const data = await readJsonFile(lockfilePath);
+    if (typeof data !== "object" || data === null || data.lockfileVersion !== LOCKFILE_VERSION) {
+      warn("lockfile.invalid_version", { path: lockfilePath });
+      return null;
+    }
+    const record = data;
+    if (typeof record.files !== "object" || record.files === null) {
+      warn("lockfile.invalid_structure", { path: lockfilePath });
+      return null;
+    }
+    return data;
+  } catch (err) {
+    warn("lockfile.read_failed", { path: lockfilePath, error: String(err) });
+    return null;
+  }
+}
 async function writeLockfile(targetDir, lockfile) {
   const lockfilePath = join4(targetDir, LOCKFILE_NAME);
   await writeJsonFile(lockfilePath, lockfile);
@@ -1642,7 +1668,7 @@ import { join as join6 } from "node:path";
 var package_default = {
   name: "oh-my-customcode",
   workspaces: ["packages/*"],
-  version: "0.49.0",
+  version: "0.51.0",
   description: "Batteries-included agent harness for Claude Code",
   type: "module",
   bin: {
@@ -1875,7 +1901,7 @@ async function handleBackupIfRequested(targetDir, backup, result) {
   result.backedUpPaths.push(backupPath);
   info("update.backup_created", { path: backupPath });
 }
-async function processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config) {
+async function processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config, lockfile) {
   const componentUpdate = updateCheck.updatableComponents.find((c) => c.name === component);
   if (!componentUpdate && !options.force) {
     result.skippedComponents.push(component);
@@ -1887,7 +1913,7 @@ async function processComponentUpdate(targetDir, component, updateCheck, customi
     return;
   }
   try {
-    const preserved = await updateComponent(targetDir, component, customizations, options, config);
+    const preserved = await updateComponent(targetDir, component, customizations, options, config, lockfile);
     result.updatedComponents.push(component);
     result.preservedFiles.push(...preserved);
   } catch (err) {
@@ -1896,9 +1922,9 @@ async function processComponentUpdate(targetDir, component, updateCheck, customi
     result.skippedComponents.push(component);
   }
 }
-async function updateAllComponents(targetDir, components, updateCheck, customizations, options, result, config) {
+async function updateAllComponents(targetDir, components, updateCheck, customizations, options, result, config, lockfile) {
   for (const component of components) {
-    await processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config);
+    await processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config, lockfile);
   }
 }
 function getEntryTemplateName2(language) {
@@ -2080,8 +2106,9 @@ async function update(options) {
     const manifestCustomizations = await resolveManifestCustomizations(options, options.targetDir);
     const configPreserveFiles = resolveConfigPreserveFiles(options, config);
     const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles, options.targetDir);
+    const lockfile = await readLockfile(options.targetDir);
     const components = options.components || getAllUpdateComponents();
-    await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config);
+    await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config, lockfile);
     await runFullUpdatePostProcessing(options, result, config);
     const lockfileResult = await generateAndWriteLockfileForDir(options.targetDir);
     if (lockfileResult.warning) {
@@ -2163,15 +2190,46 @@ async function componentHasUpdate(_targetDir, component, config) {
   const latestVersion = await getLatestVersion();
   return installedVersion !== latestVersion;
 }
-async function collectProtectedSkipPaths(srcPath, destPath, componentPath, forceOverwriteAll) {
+async function shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile) {
+  if (!lockfile) {
+    return true;
+  }
+  const lockfileEntry = lockfile.files[lockfileKey];
+  if (!lockfileEntry) {
+    return false;
+  }
+  if (!await fileExists(targetFilePath)) {
+    return false;
+  }
+  try {
+    const currentHash = await computeFileHash(targetFilePath);
+    return currentHash !== lockfileEntry.templateHash;
+  } catch {
+    return true;
+  }
+}
+async function collectProtectedSkipPaths(srcPath, destPath, componentPath, forceOverwriteAll, lockfile, targetDir) {
   if (forceOverwriteAll) {
-    const warnedPaths = await findProtectedFilesInDir(srcPath, componentPath);
-    return { skipPaths: [], warnedPaths };
+    const warnedPaths2 = await findProtectedFilesInDir(srcPath, componentPath);
+    return { skipPaths: [], warnedPaths: warnedPaths2, updatedPaths: [] };
   }
   const protectedRelative = await findProtectedFilesInDir(srcPath, componentPath);
   const path = await import("node:path");
-  const skipPaths = protectedRelative.map((p) => path.relative(destPath, join6(destPath, p)));
-  return { skipPaths, warnedPaths: protectedRelative };
+  const skipPaths = [];
+  const warnedPaths = [];
+  const updatedPaths = [];
+  for (const p of protectedRelative) {
+    const targetFilePath = join6(targetDir, componentPath, p);
+    const lockfileKey = `${componentPath}/${p}`.replace(/\\/g, "/");
+    const shouldSkip = await shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile);
+    if (shouldSkip) {
+      skipPaths.push(path.relative(destPath, join6(destPath, p)));
+      warnedPaths.push(p);
+    } else {
+      updatedPaths.push(p);
+    }
+  }
+  return { skipPaths, warnedPaths, updatedPaths };
 }
 function isEntryProtected(relPath, componentRelativePrefix) {
   if (isProtectedFile(relPath)) {
@@ -2207,7 +2265,7 @@ async function findProtectedFilesInDir(dirPath, componentRelativePrefix) {
   }
   return protected_;
 }
-async function updateComponent(targetDir, component, customizations, options, config) {
+async function updateComponent(targetDir, component, customizations, options, config, lockfile) {
   const preservedFiles = [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
@@ -2224,7 +2282,11 @@ async function updateComponent(targetDir, component, customizations, options, co
       skipPaths.push(cc.path);
     }
   }
-  const { skipPaths: protectedSkipPaths, warnedPaths: protectedWarnedPaths } = await collectProtectedSkipPaths(srcPath, destPath, componentPath, !!options.forceOverwriteAll);
+  const {
+    skipPaths: protectedSkipPaths,
+    warnedPaths: protectedWarnedPaths,
+    updatedPaths: protectedUpdatedPaths
+  } = await collectProtectedSkipPaths(srcPath, destPath, componentPath, !!options.forceOverwriteAll, lockfile, targetDir);
   for (const protectedPath of protectedWarnedPaths) {
     if (options.forceOverwriteAll) {
       warn("update.protected_file_force_overwrite", {
@@ -2236,10 +2298,17 @@ async function updateComponent(targetDir, component, customizations, options, co
       warn("update.protected_file_skipped", {
         file: protectedPath,
         component,
-        hint: "File contains AI behavioral constraints and was not updated. Use --force-overwrite-all to override."
+        hint: "File was modified by user and preserved. Use --force-overwrite-all to override."
       });
     }
   }
+  for (const updatedPath of protectedUpdatedPaths) {
+    info("update.protected_file_updated", {
+      file: updatedPath,
+      component,
+      hint: "Protected file updated (unmodified by user, matches lockfile hash)."
+    });
+  }
   skipPaths.push(...protectedSkipPaths);
   const path = await import("node:path");
   const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join6(targetDir, p)));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oh-my-customcode",
   "workspaces": ["packages/*"],
-  "version": "0.49.0",
+  "version": "0.51.0",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

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

@@ -0,0 +1,248 @@
+---
+name: scout
+description: Analyze external URL to evaluate fit with oh-my-customcode 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-customcode 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(CLAUDE.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(.claude/skills/*/SKILL.md)` — list existing skills for overlap detection
+
+### Phase 3: Fit Analysis
+
+Spawn 1 sonnet agent with the following analysis prompt.
+
+**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 | `/omcustom: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 |