release: v0.3.2

- Add Zod schema validation following Anthropic Agent Skills Spec v1.0
- Include basePath in skill output for path resolution
- Simplify tool description and output format
- Add validation error logging for invalid skills

🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)

README.ko.md

@@ -166,6 +166,7 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
   │       └── Button.tsx     # 이 파일을 읽으면 위 3개 AGENTS.md 모두 주입
   ```
   `Button.tsx`를 읽으면 순서대로 주입됩니다: `project/AGENTS.md` → `src/AGENTS.md` → `components/AGENTS.md`. 각 디렉토리의 컨텍스트는 세션당 한 번만 주입됩니다. Claude Code의 CLAUDE.md 기능에서 영감을 받았습니다.
+- **Directory README.md Injector**: 파일을 읽을 때 `README.md` 내용을 자동으로 주입합니다. AGENTS.md Injector와 동일하게 동작하며, 파일 디렉토리부터 프로젝트 루트까지 탐색합니다. LLM 에이전트에게 프로젝트 문서 컨텍스트를 제공합니다. 각 디렉토리의 README는 세션당 한 번만 주입됩니다.
 - **Think Mode**: 확장된 사고(Extended Thinking)가 필요한 상황을 자동으로 감지하고 모드를 전환합니다. 사용자가 깊은 사고를 요청하는 표현(예: "think deeply", "ultrathink")을 감지하면, 추론 능력을 극대화하도록 모델 설정을 동적으로 조정합니다.
 - **Anthropic Auto Compact**: Anthropic 모델 사용 시 컨텍스트 한계에 도달하면 대화 기록을 자동으로 압축하여 효율적으로 관리합니다.
 - **Empty Task Response Detector**: 서브 에이전트가 수행한 작업이 비어있거나 무의미한 응답을 반환하는 경우를 감지하여, 오류 없이 우아하게 처리합니다.

README.md

@@ -163,6 +163,7 @@ I believe in the right tool for the job. For your wallet's sake, use CLIProxyAPI
   │       └── Button.tsx     # Reading this injects ALL 3 AGENTS.md files
   ```
   When reading `Button.tsx`, the hook injects contexts in order: `project/AGENTS.md` → `src/AGENTS.md` → `components/AGENTS.md`. Each directory's context is injected only once per session. Inspired by Claude Code's CLAUDE.md feature.
+- **Directory README.md Injector**: Automatically injects `README.md` contents when reading files. Works identically to the AGENTS.md Injector, searching upward from the file's directory to project root. Provides project documentation context to the LLM agent. Each directory's README is injected only once per session.
 - **Think Mode**: Automatic extended thinking detection and mode switching. Detects when user requests deep thinking (e.g., "think deeply", "ultrathink") and dynamically adjusts model settings for enhanced reasoning.
 - **Anthropic Auto Compact**: Automatically compacts conversation history when approaching context limits for Anthropic models.
 - **Empty Task Response Detector**: Detects when subagent tasks return empty or meaningless responses and handles gracefully.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/hooks/directory-readme-injector/constants.ts

@@ -0,0 +1,9 @@
+import { join } from "node:path";
+import { xdgData } from "xdg-basedir";
+
+export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const README_INJECTOR_STORAGE = join(
+  OPENCODE_STORAGE,
+  "directory-readme",
+);
+export const README_FILENAME = "README.md";

src/hooks/directory-readme-injector/index.ts

@@ -0,0 +1,126 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import {
+  loadInjectedPaths,
+  saveInjectedPaths,
+  clearInjectedPaths,
+} from "./storage";
+import { README_FILENAME } from "./constants";
+
+interface ToolExecuteInput {
+  tool: string;
+  sessionID: string;
+  callID: string;
+}
+
+interface ToolExecuteOutput {
+  title: string;
+  output: string;
+  metadata: unknown;
+}
+
+interface EventInput {
+  event: {
+    type: string;
+    properties?: unknown;
+  };
+}
+
+export function createDirectoryReadmeInjectorHook(ctx: PluginInput) {
+  const sessionCaches = new Map<string, Set<string>>();
+
+  function getSessionCache(sessionID: string): Set<string> {
+    if (!sessionCaches.has(sessionID)) {
+      sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
+    }
+    return sessionCaches.get(sessionID)!;
+  }
+
+  function resolveFilePath(title: string): string | null {
+    if (!title) return null;
+    if (title.startsWith("/")) return title;
+    return resolve(ctx.directory, title);
+  }
+
+  function findReadmeMdUp(startDir: string): string[] {
+    const found: string[] = [];
+    let current = startDir;
+
+    while (true) {
+      const readmePath = join(current, README_FILENAME);
+      if (existsSync(readmePath)) {
+        found.push(readmePath);
+      }
+
+      if (current === ctx.directory) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      if (!parent.startsWith(ctx.directory)) break;
+      current = parent;
+    }
+
+    return found.reverse();
+  }
+
+  const toolExecuteAfter = async (
+    input: ToolExecuteInput,
+    output: ToolExecuteOutput,
+  ) => {
+    if (input.tool.toLowerCase() !== "read") return;
+
+    const filePath = resolveFilePath(output.title);
+    if (!filePath) return;
+
+    const dir = dirname(filePath);
+    const cache = getSessionCache(input.sessionID);
+    const readmePaths = findReadmeMdUp(dir);
+
+    const toInject: { path: string; content: string }[] = [];
+
+    for (const readmePath of readmePaths) {
+      const readmeDir = dirname(readmePath);
+      if (cache.has(readmeDir)) continue;
+
+      try {
+        const content = readFileSync(readmePath, "utf-8");
+        toInject.push({ path: readmePath, content });
+        cache.add(readmeDir);
+      } catch {}
+    }
+
+    if (toInject.length === 0) return;
+
+    for (const { path, content } of toInject) {
+      output.output += `\n\n[Project README: ${path}]\n${content}`;
+    }
+
+    saveInjectedPaths(input.sessionID, cache);
+  };
+
+  const eventHandler = async ({ event }: EventInput) => {
+    const props = event.properties as Record<string, unknown> | undefined;
+
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info as { id?: string } | undefined;
+      if (sessionInfo?.id) {
+        sessionCaches.delete(sessionInfo.id);
+        clearInjectedPaths(sessionInfo.id);
+      }
+    }
+
+    if (event.type === "session.compacted") {
+      const sessionID = (props?.sessionID ??
+        (props?.info as { id?: string } | undefined)?.id) as string | undefined;
+      if (sessionID) {
+        sessionCaches.delete(sessionID);
+        clearInjectedPaths(sessionID);
+      }
+    }
+  };
+
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler,
+  };
+}

src/hooks/directory-readme-injector/storage.ts

@@ -0,0 +1,48 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { README_INJECTOR_STORAGE } from "./constants";
+import type { InjectedPathsData } from "./types";
+
+function getStoragePath(sessionID: string): string {
+  return join(README_INJECTOR_STORAGE, `${sessionID}.json`);
+}
+
+export function loadInjectedPaths(sessionID: string): Set<string> {
+  const filePath = getStoragePath(sessionID);
+  if (!existsSync(filePath)) return new Set();
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const data: InjectedPathsData = JSON.parse(content);
+    return new Set(data.injectedPaths);
+  } catch {
+    return new Set();
+  }
+}
+
+export function saveInjectedPaths(sessionID: string, paths: Set<string>): void {
+  if (!existsSync(README_INJECTOR_STORAGE)) {
+    mkdirSync(README_INJECTOR_STORAGE, { recursive: true });
+  }
+
+  const data: InjectedPathsData = {
+    sessionID,
+    injectedPaths: [...paths],
+    updatedAt: Date.now(),
+  };
+
+  writeFileSync(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+}
+
+export function clearInjectedPaths(sessionID: string): void {
+  const filePath = getStoragePath(sessionID);
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+  }
+}

src/hooks/directory-readme-injector/types.ts

@@ -0,0 +1,5 @@
+export interface InjectedPathsData {
+  sessionID: string;
+  injectedPaths: string[];
+  updatedAt: number;
+}

src/hooks/index.ts

@@ -5,6 +5,7 @@ export { createSessionRecoveryHook } from "./session-recovery";
 export { createCommentCheckerHooks } from "./comment-checker";
 export { createGrepOutputTruncatorHook } from "./grep-output-truncator";
 export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
+export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createAnthropicAutoCompactHook } from "./anthropic-auto-compact";
 export { createThinkModeHook } from "./think-mode";

src/index.ts

@@ -7,6 +7,7 @@ import {
   createCommentCheckerHooks,
   createGrepOutputTruncatorHook,
   createDirectoryAgentsInjectorHook,
+  createDirectoryReadmeInjectorHook,
   createEmptyTaskResponseDetectorHook,
   createThinkModeHook,
   createClaudeCodeHooksHook,
@@ -40,33 +41,77 @@ import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig } from "./config";
 import { log } from "./shared/logger";
 import * as fs from "fs";
 import * as path from "path";
+import * as os from "os";
+
+function loadConfigFromPath(configPath: string): OhMyOpenCodeConfig | null {
+  try {
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const rawConfig = JSON.parse(content);
+      const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+
+      if (!result.success) {
+        log(`Config validation error in ${configPath}:`, result.error.issues);
+        return null;
+      }
+
+      log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+      return result.data;
+    }
+  } catch (err) {
+    log(`Error loading config from ${configPath}:`, err);
+  }
+  return null;
+}
+
+function mergeConfigs(base: OhMyOpenCodeConfig, override: OhMyOpenCodeConfig): OhMyOpenCodeConfig {
+  return {
+    ...base,
+    ...override,
+    agents: override.agents !== undefined
+      ? { ...(base.agents ?? {}), ...override.agents }
+      : base.agents,
+    disabled_agents: [
+      ...new Set([...(base.disabled_agents ?? []), ...(override.disabled_agents ?? [])])
+    ],
+    disabled_mcps: [
+      ...new Set([...(base.disabled_mcps ?? []), ...(override.disabled_mcps ?? [])])
+    ],
+  };
+}
 
 function loadPluginConfig(directory: string): OhMyOpenCodeConfig {
-  const configPaths = [
-    path.join(directory, "oh-my-opencode.json"),
-    path.join(directory, ".oh-my-opencode.json"),
+  // User-level config paths
+  const userConfigPaths = [
+    path.join(os.homedir(), ".config", "opencode", "oh-my-opencode.json"),
   ];
 
-  for (const configPath of configPaths) {
-    try {
-      if (fs.existsSync(configPath)) {
-        const content = fs.readFileSync(configPath, "utf-8");
-        const rawConfig = JSON.parse(content);
-        const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+  // Project-level config paths (higher precedence)
+  const projectConfigPaths = [
+    path.join(directory, ".opencode", "oh-my-opencode.json"),
+  ];
 
-        if (!result.success) {
-          log(`Config validation error in ${configPath}:`, result.error.issues);
-          return {};
-        }
-
-        return result.data;
-      }
-    } catch {
-      // Ignore parse errors, use defaults
+  // Load user config first
+  let config: OhMyOpenCodeConfig = {};
+  for (const configPath of userConfigPaths) {
+    const userConfig = loadConfigFromPath(configPath);
+    if (userConfig) {
+      config = userConfig;
+      break;
     }
   }
 
-  return {};
+  // Override with project config
+  for (const configPath of projectConfigPaths) {
+    const projectConfig = loadConfigFromPath(configPath);
+    if (projectConfig) {
+      config = mergeConfigs(config, projectConfig);
+      break;
+    }
+  }
+
+  log("Final merged config", { agents: config.agents, disabled_agents: config.disabled_agents, disabled_mcps: config.disabled_mcps });
+  return config;
 }
 
 const OhMyOpenCodePlugin: Plugin = async (ctx) => {
@@ -78,6 +123,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
   const commentChecker = createCommentCheckerHooks();
   const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
   const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
+  const directoryReadmeInjector = createDirectoryReadmeInjectorHook(ctx);
   const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
   const thinkMode = createThinkModeHook();
   const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {});
@@ -141,6 +187,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       await todoContinuationEnforcer(input);
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
+      await directoryReadmeInjector.event(input);
       await thinkMode.event(input);
       await anthropicAutoCompact.event(input);
 
@@ -259,6 +306,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       await contextWindowMonitor["tool.execute.after"](input, output);
       await commentChecker["tool.execute.after"](input, output);
       await directoryAgentsInjector["tool.execute.after"](input, output);
+      await directoryReadmeInjector["tool.execute.after"](input, output);
       await emptyTaskResponseDetector["tool.execute.after"](input, output);
 
       if (input.sessionID === getMainSessionID()) {

src/tools/skill/tools.ts

@@ -2,8 +2,23 @@ import { tool } from "@opencode-ai/plugin"
 import { existsSync, readdirSync, statSync, readlinkSync, readFileSync } from "fs"
 import { homedir } from "os"
 import { join, resolve, basename } from "path"
+import { z } from "zod/v4"
 import { parseFrontmatter, resolveCommandsInText } from "../../shared"
-import type { SkillScope, SkillMetadata, SkillInfo, LoadedSkill } from "./types"
+import { SkillFrontmatterSchema } from "./types"
+import type { SkillScope, SkillMetadata, SkillInfo, LoadedSkill, SkillFrontmatter } from "./types"
+
+function parseSkillFrontmatter(data: Record<string, unknown>): SkillFrontmatter {
+  return {
+    name: typeof data.name === "string" ? data.name : "",
+    description: typeof data.description === "string" ? data.description : "",
+    license: typeof data.license === "string" ? data.license : undefined,
+    "allowed-tools": Array.isArray(data["allowed-tools"]) ? data["allowed-tools"] : undefined,
+    metadata:
+      typeof data.metadata === "object" && data.metadata !== null
+        ? (data.metadata as Record<string, string>)
+        : undefined,
+  }
+}
 
 function discoverSkillsFromDir(
   skillsDir: string,
@@ -93,10 +108,14 @@ async function parseSkillMd(skillPath: string): Promise<SkillInfo | null> {
     content = await resolveCommandsInText(content)
     const { data, body } = parseFrontmatter(content)
 
+    const frontmatter = parseSkillFrontmatter(data)
+
     const metadata: SkillMetadata = {
-      name: data.name || basename(skillPath),
-      description: data.description || "",
-      license: data.license,
+      name: frontmatter.name || basename(skillPath),
+      description: frontmatter.description,
+      license: frontmatter.license,
+      allowedTools: frontmatter["allowed-tools"],
+      metadata: frontmatter.metadata,
     }
 
     const referencesDir = join(resolvedPath, "references")
@@ -118,6 +137,7 @@ async function parseSkillMd(skillPath: string): Promise<SkillInfo | null> {
     return {
       name: metadata.name,
       path: resolvedPath,
+      basePath: resolvedPath,
       metadata,
       content: body,
       references,
@@ -202,6 +222,7 @@ async function loadSkillWithReferences(
         content = await resolveCommandsInText(content)
         referencesLoaded.push({ path: ref, content })
       } catch {
+        // Skip unreadable references
       }
     }
   }
@@ -209,6 +230,7 @@ async function loadSkillWithReferences(
   return {
     name: skill.name,
     metadata: skill.metadata,
+    basePath: skill.basePath,
     body: skill.content,
     referencesLoaded,
   }
@@ -234,31 +256,24 @@ function formatLoadedSkills(loadedSkills: LoadedSkill[]): string {
     return "No skills loaded."
   }
 
-  const sections: string[] = ["# Loaded Skills\n"]
+  const skill = loadedSkills[0]
+  const sections: string[] = []
 
-  for (const skill of loadedSkills) {
-    sections.push(`## ${skill.metadata.name}\n`)
-    sections.push(`**Description**: ${skill.metadata.description || "(no description)"}\n`)
-    sections.push("### Skill Instructions\n")
-    sections.push(skill.body.trim())
+  sections.push(`Base directory for this skill: ${skill.basePath}/`)
+  sections.push("")
+  sections.push(skill.body.trim())
 
-    if (skill.referencesLoaded.length > 0) {
-      sections.push("\n### Loaded References\n")
-      for (const ref of skill.referencesLoaded) {
-        sections.push(`#### ${ref.path}\n`)
-        sections.push("```")
-        sections.push(ref.content.trim())
-        sections.push("```\n")
-      }
+  if (skill.referencesLoaded.length > 0) {
+    sections.push("\n---\n### Loaded References\n")
+    for (const ref of skill.referencesLoaded) {
+      sections.push(`#### ${ref.path}\n`)
+      sections.push("```")
+      sections.push(ref.content.trim())
+      sections.push("```\n")
     }
-
-    sections.push("\n---\n")
   }
 
-  const skillNames = loadedSkills.map((s) => s.metadata.name).join(", ")
-  sections.push(`**Skills loaded**: ${skillNames}`)
-  sections.push(`**Total**: ${loadedSkills.length} skill(s)`)
-  sections.push("\nPlease confirm these skills match your needs before proceeding.")
+  sections.push(`\n---\n**Launched skill**: ${skill.metadata.name}`)
 
   return sections.join("\n")
 }
@@ -266,25 +281,7 @@ function formatLoadedSkills(loadedSkills: LoadedSkill[]): string {
 export const skill = tool({
   description: `Execute a skill within the main conversation.
 
-When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
-
-How to use skills:
-- Invoke skills using this tool with the skill name only (no arguments)
-- When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task
-
-Important:
-- Only use skills listed in Available Skills below
-- Do not invoke a skill that is already running
-
-Skills are loaded from:
-- ~/.claude/skills/ (user scope - global skills)
-- ./.claude/skills/ (project scope - project-specific skills)
-
-Each skill contains:
-- SKILL.md: Main instructions with YAML frontmatter (name, description)
-- references/: Documentation files loaded into context as needed
-- scripts/: Executable code for deterministic operations
-- assets/: Files used in output (templates, icons, etc.)
+When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task.
 
 Available Skills:
 ${skillListForDescription}`,

src/tools/skill/types.ts

@@ -1,14 +1,36 @@
+import { z } from "zod/v4"
+
 export type SkillScope = "user" | "project"
 
+/**
+ * Zod schema for skill frontmatter validation
+ * Following Anthropic Agent Skills Specification v1.0
+ */
+export const SkillFrontmatterSchema = z.object({
+  name: z
+    .string()
+    .regex(/^[a-z0-9-]+$/, "Name must be lowercase alphanumeric with hyphens only")
+    .min(1, "Name cannot be empty"),
+  description: z.string().min(20, "Description must be at least 20 characters for discoverability"),
+  license: z.string().optional(),
+  "allowed-tools": z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.string()).optional(),
+})
+
+export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>
+
 export interface SkillMetadata {
   name: string
   description: string
   license?: string
+  allowedTools?: string[]
+  metadata?: Record<string, string>
 }
 
 export interface SkillInfo {
   name: string
   path: string
+  basePath: string
   metadata: SkillMetadata
   content: string
   references: string[]
@@ -19,6 +41,7 @@ export interface SkillInfo {
 export interface LoadedSkill {
   name: string
   metadata: SkillMetadata
+  basePath: string
   body: string
   referencesLoaded: Array<{ path: string; content: string }>
 }