@kood/claude-code 0.7.11 → 0.7.12

package/dist/index.js

@@ -22,9 +22,9 @@ var banner = () => {
 };
 
 // src/commands/init.ts
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import os2 from "os";
-import path11 from "path";
+import path12 from "path";
 
 // src/features/templates/template-path-resolver.ts
 import path2 from "path";
@@ -419,6 +419,38 @@ var checkAllExtrasExist = async (_templates) => {
 };
 
 // src/features/extras/extras-installer.ts
+import fs7 from "fs-extra";
+import path9 from "path";
+async function registerSessionStartHook(targetDir) {
+  const settingsPath = path9.join(targetDir, ".claude", "settings.local.json");
+  const hookCommand = ".claude/hooks/session-env-setup.sh";
+  let config = {};
+  if (await fs7.pathExists(settingsPath)) {
+    try {
+      config = await fs7.readJson(settingsPath);
+    } catch {
+      config = {};
+    }
+  }
+  if (!config.hooks) {
+    config.hooks = {};
+  }
+  if (!config.hooks.SessionStart) {
+    config.hooks.SessionStart = [];
+  }
+  const alreadyRegistered = config.hooks.SessionStart.some(
+    (hook) => hook.type === "command" && hook.command === hookCommand
+  );
+  if (!alreadyRegistered) {
+    config.hooks.SessionStart.push({
+      type: "command",
+      command: hookCommand
+    });
+    await fs7.ensureDir(path9.dirname(settingsPath));
+    await fs7.writeJson(settingsPath, config, { spaces: 2 });
+    logger.step("Registered SessionStart hook for CLAUDE_SCRIPTS_ROOT");
+  }
+}
 function logExistingFilesUpdate(existingClaudeFiles) {
   if (existingClaudeFiles.length > 0) {
     logger.info("Updating existing extras:");
@@ -571,6 +603,9 @@ async function installExtras(templates, targetDir, flags, availability) {
     installHooks,
     availability.hasHooks
   );
+  if (installHooks && hooksResult.files > 0) {
+    await registerSessionStartHook(targetDir);
+  }
   const totalFiles = skillsResult.files + commandsResult.files + agentsResult.files + instructionsResult.files + scriptsResult.files + hooksResult.files;
   const totalDirectories = skillsResult.directories + commandsResult.directories + agentsResult.directories + instructionsResult.directories + scriptsResult.directories + hooksResult.directories;
   return { files: totalFiles, directories: totalDirectories };
@@ -748,8 +783,8 @@ async function promptCodexSync(options) {
 }
 
 // src/shared/gitignore-manager.ts
-import fs7 from "fs-extra";
-import path9 from "path";
+import fs8 from "fs-extra";
+import path10 from "path";
 var CLAUDE_GENERATED_FOLDERS = [
   ".claude/brainstorms/",
   ".claude/crawler/",
@@ -778,13 +813,13 @@ function parseIgnoreLine(line) {
 }
 async function updateGitignore(targetDir, options = {}) {
   const { includeCodex = false } = options;
-  const gitignorePath = path9.join(targetDir, ".gitignore");
+  const gitignorePath = path10.join(targetDir, ".gitignore");
   const sectionComment = "# Claude Code generated files";
   const targetFolders = includeCodex ? [...CLAUDE_GENERATED_FOLDERS, ...CODEX_GENERATED_FOLDERS] : CLAUDE_GENERATED_FOLDERS;
   let content = "";
   let hasGitignore = false;
   try {
-    content = await fs7.readFile(gitignorePath, "utf-8");
+    content = await fs8.readFile(gitignorePath, "utf-8");
     hasGitignore = true;
   } catch {
     content = "";
@@ -817,7 +852,7 @@ async function updateGitignore(targetDir, options = {}) {
   if (!newContent.endsWith(eol)) {
     newContent += eol;
   }
-  await fs7.writeFile(gitignorePath, newContent, "utf-8");
+  await fs8.writeFile(gitignorePath, newContent, "utf-8");
   if (hasGitignore) {
     logger.success(`.gitignore updated with ${linesToAdd.length} patterns`);
   } else {
@@ -826,9 +861,9 @@ async function updateGitignore(targetDir, options = {}) {
 }
 
 // src/features/codex-sync/codex-sync.ts
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import os from "os";
-import path10 from "path";
+import path11 from "path";
 var RESERVED_CODEX_SKILL_DIRS = /* @__PURE__ */ new Set([".system", "claude-commands"]);
 var COMMAND_INSTRUCTION_PREFIX_REGEX = /^@\.\.\/instructions\//gm;
 var COMMAND_INSTRUCTION_PREFIX_REPLACEMENT = "@../../../instructions/";
@@ -862,13 +897,13 @@ function extractDescriptionFromFrontmatter(markdown) {
   return void 0;
 }
 function buildCommandSkillContent(commandPath, commandRaw) {
-  const commandName = path10.basename(commandPath, ".md");
+  const commandName = path11.basename(commandPath, ".md");
   const normalizedCommand = normalizeLineEndings(commandRaw).trim();
   const rewrittenCommand = normalizedCommand.replace(
     COMMAND_INSTRUCTION_PREFIX_REGEX,
     COMMAND_INSTRUCTION_PREFIX_REPLACEMENT
   );
-  const sourcePath = path10.resolve(commandPath);
+  const sourcePath = path11.resolve(commandPath);
   const description = extractDescriptionFromFrontmatter(normalizedCommand) || `${commandName} command imported from .claude/commands`;
   return `---
 name: ${yamlQuote(commandName)}
@@ -946,9 +981,9 @@ function getProjectState(claudeState, targetDir) {
   if (!isRecord(projects)) {
     return void 0;
   }
-  const normalizedTarget = path10.resolve(targetDir);
+  const normalizedTarget = path11.resolve(targetDir);
   for (const [projectPath, projectState] of Object.entries(projects)) {
-    if (path10.resolve(projectPath) !== normalizedTarget) {
+    if (path11.resolve(projectPath) !== normalizedTarget) {
       continue;
     }
     if (isRecord(projectState)) {
@@ -979,11 +1014,11 @@ function filterMcpJsonServersByProjectState(servers, projectState) {
   return Object.fromEntries(filteredEntries);
 }
 async function readJsonFile(filePath) {
-  if (!await fs8.pathExists(filePath)) {
+  if (!await fs9.pathExists(filePath)) {
     return void 0;
   }
   try {
-    const raw = await fs8.readFile(filePath, "utf8");
+    const raw = await fs9.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) {
       return void 0;
@@ -1160,10 +1195,10 @@ function mergeCodexConfigToml(existingToml, renderedMcpBlocks) {
 ${mcp}`;
 }
 async function loadClaudeMcpServers(targetDir) {
-  const homeDir = path10.resolve(os.homedir());
-  const normalizedTarget = path10.resolve(targetDir);
+  const homeDir = path11.resolve(os.homedir());
+  const normalizedTarget = path11.resolve(targetDir);
   const isUserScope = normalizedTarget === homeDir;
-  const claudeStatePath = path10.join(homeDir, CLAUDE_STATE_FILE);
+  const claudeStatePath = path11.join(homeDir, CLAUDE_STATE_FILE);
   const claudeState = await readJsonFile(claudeStatePath);
   if (isUserScope) {
     return {
@@ -1173,7 +1208,7 @@ async function loadClaudeMcpServers(targetDir) {
   }
   const projectState = claudeState ? getProjectState(claudeState, normalizedTarget) : void 0;
   const projectServers = normalizeClaudeMcpServers(projectState?.mcpServers);
-  const localMcpPath = path10.join(normalizedTarget, CLAUDE_LOCAL_MCP_FILE);
+  const localMcpPath = path11.join(normalizedTarget, CLAUDE_LOCAL_MCP_FILE);
   const localMcpState = await readJsonFile(localMcpPath);
   const localMcpServers = filterMcpJsonServersByProjectState(
     normalizeClaudeMcpServers(localMcpState?.mcpServers),
@@ -1188,18 +1223,18 @@ async function loadClaudeMcpServers(targetDir) {
   };
 }
 async function syncMcpServers(targetDir) {
-  const homeDir = path10.resolve(os.homedir());
-  const normalizedTarget = path10.resolve(targetDir);
+  const homeDir = path11.resolve(os.homedir());
+  const normalizedTarget = path11.resolve(targetDir);
   const isUserScope = normalizedTarget === homeDir;
-  const codexBaseDir = isUserScope ? path10.join(homeDir, ".codex") : path10.join(normalizedTarget, ".codex");
-  const codexMcpConfigPath = path10.join(codexBaseDir, CODEX_CONFIG_FILE);
+  const codexBaseDir = isUserScope ? path11.join(homeDir, ".codex") : path11.join(normalizedTarget, ".codex");
+  const codexMcpConfigPath = path11.join(codexBaseDir, CODEX_CONFIG_FILE);
   const { scope, servers } = await loadClaudeMcpServers(normalizedTarget);
   const codexServers = Object.entries(servers).map(([name, server]) => [name, toCodexMcpServer(server)]).filter((entry) => Boolean(entry[1])).sort((a, b) => a[0].localeCompare(b[0]));
   const renderedMcpBlocks = codexServers.map(([name, server]) => renderCodexMcpServer(name, server)).join("\n\n");
-  const existingConfig = await fs8.pathExists(codexMcpConfigPath) ? await fs8.readFile(codexMcpConfigPath, "utf8") : "";
+  const existingConfig = await fs9.pathExists(codexMcpConfigPath) ? await fs9.readFile(codexMcpConfigPath, "utf8") : "";
   const nextConfig = mergeCodexConfigToml(existingConfig, renderedMcpBlocks);
-  await fs8.ensureDir(codexBaseDir);
-  await fs8.writeFile(codexMcpConfigPath, `${nextConfig.trimEnd()}
+  await fs9.ensureDir(codexBaseDir);
+  await fs9.writeFile(codexMcpConfigPath, `${nextConfig.trimEnd()}
 `);
   return {
     codexMcpConfigPath,
@@ -1208,16 +1243,16 @@ async function syncMcpServers(targetDir) {
   };
 }
 async function syncSkills(claudeSkillsDir, codexSkillsDir) {
-  await fs8.ensureDir(codexSkillsDir);
+  await fs9.ensureDir(codexSkillsDir);
   let sourceSkillNames = [];
-  if (await fs8.pathExists(claudeSkillsDir)) {
-    const sourceEntries = await fs8.readdir(claudeSkillsDir, {
+  if (await fs9.pathExists(claudeSkillsDir)) {
+    const sourceEntries = await fs9.readdir(claudeSkillsDir, {
       withFileTypes: true
     });
     sourceSkillNames = sourceEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => name !== ".system");
   }
   const sourceSkillSet = new Set(sourceSkillNames);
-  const codexEntries = await fs8.readdir(codexSkillsDir, {
+  const codexEntries = await fs9.readdir(codexSkillsDir, {
     withFileTypes: true
   });
   for (const entry of codexEntries) {
@@ -1228,40 +1263,40 @@ async function syncSkills(claudeSkillsDir, codexSkillsDir) {
       continue;
     }
     if (!sourceSkillSet.has(entry.name)) {
-      await fs8.remove(path10.join(codexSkillsDir, entry.name));
+      await fs9.remove(path11.join(codexSkillsDir, entry.name));
     }
   }
   for (const skillName of sourceSkillNames) {
-    const src = path10.join(claudeSkillsDir, skillName);
-    const dest = path10.join(codexSkillsDir, skillName);
-    if (await fs8.pathExists(dest)) {
-      await fs8.remove(dest);
+    const src = path11.join(claudeSkillsDir, skillName);
+    const dest = path11.join(codexSkillsDir, skillName);
+    if (await fs9.pathExists(dest)) {
+      await fs9.remove(dest);
     }
     await copyRecursive(src, dest, { files: 0, directories: 0 });
   }
   return sourceSkillNames.length;
 }
 async function syncCommands(claudeCommandsDir, codexCommandsDir) {
-  if (!await fs8.pathExists(claudeCommandsDir)) {
-    await fs8.remove(codexCommandsDir);
+  if (!await fs9.pathExists(claudeCommandsDir)) {
+    await fs9.remove(codexCommandsDir);
     return 0;
   }
-  const entries = await fs8.readdir(claudeCommandsDir, { withFileTypes: true });
+  const entries = await fs9.readdir(claudeCommandsDir, { withFileTypes: true });
   const commandFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   if (commandFiles.length === 0) {
-    await fs8.remove(codexCommandsDir);
+    await fs9.remove(codexCommandsDir);
     return 0;
   }
-  await fs8.remove(codexCommandsDir);
-  await fs8.ensureDir(codexCommandsDir);
+  await fs9.remove(codexCommandsDir);
+  await fs9.ensureDir(codexCommandsDir);
   for (const commandFile of commandFiles) {
-    const commandPath = path10.join(claudeCommandsDir, commandFile);
-    const commandRaw = await fs8.readFile(commandPath, "utf8");
-    const commandName = path10.basename(commandFile, ".md");
-    const skillDir = path10.join(codexCommandsDir, commandName);
-    const skillPath = path10.join(skillDir, "SKILL.md");
-    await fs8.ensureDir(skillDir);
-    await fs8.writeFile(
+    const commandPath = path11.join(claudeCommandsDir, commandFile);
+    const commandRaw = await fs9.readFile(commandPath, "utf8");
+    const commandName = path11.basename(commandFile, ".md");
+    const skillDir = path11.join(codexCommandsDir, commandName);
+    const skillPath = path11.join(skillDir, "SKILL.md");
+    await fs9.ensureDir(skillDir);
+    await fs9.writeFile(
       skillPath,
       buildCommandSkillContent(commandPath, commandRaw)
     );
@@ -1269,12 +1304,12 @@ async function syncCommands(claudeCommandsDir, codexCommandsDir) {
   return commandFiles.length;
 }
 async function syncInstructions(claudeInstructionsDir, codexInstructionsDir) {
-  if (!await fs8.pathExists(claudeInstructionsDir)) {
-    await fs8.remove(codexInstructionsDir);
+  if (!await fs9.pathExists(claudeInstructionsDir)) {
+    await fs9.remove(codexInstructionsDir);
     return 0;
   }
-  await fs8.remove(codexInstructionsDir);
-  await fs8.ensureDir(codexInstructionsDir);
+  await fs9.remove(codexInstructionsDir);
+  await fs9.ensureDir(codexInstructionsDir);
   const counter = { files: 0, directories: 0 };
   await copyRecursive(claudeInstructionsDir, codexInstructionsDir, counter);
   return counter.files;
@@ -1295,12 +1330,12 @@ function extractReferenceCandidate(line) {
   return candidate;
 }
 async function collectSkillMarkdownFiles(rootDir, collector = []) {
-  if (!await fs8.pathExists(rootDir)) {
+  if (!await fs9.pathExists(rootDir)) {
     return collector;
   }
-  const entries = await fs8.readdir(rootDir, { withFileTypes: true });
+  const entries = await fs9.readdir(rootDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path10.join(rootDir, entry.name);
+    const fullPath = path11.join(rootDir, entry.name);
     if (entry.isDirectory()) {
       await collectSkillMarkdownFiles(fullPath, collector);
       continue;
@@ -1316,7 +1351,7 @@ async function validateSkillReferences(codexSkillsDir) {
   let count = 0;
   const samples = [];
   for (const skillFile of skillFiles) {
-    const content = await fs8.readFile(skillFile, "utf8");
+    const content = await fs9.readFile(skillFile, "utf8");
     const lines = normalizeLineEndings(content).split("\n");
     for (const line of lines) {
       const candidate = extractReferenceCandidate(line);
@@ -1327,8 +1362,8 @@ async function validateSkillReferences(codexSkillsDir) {
       if (!referencePath) {
         continue;
       }
-      const resolvedPath = path10.resolve(path10.dirname(skillFile), referencePath);
-      if (await fs8.pathExists(resolvedPath)) {
+      const resolvedPath = path11.resolve(path11.dirname(skillFile), referencePath);
+      if (await fs9.pathExists(resolvedPath)) {
         continue;
       }
       count += 1;
@@ -1344,15 +1379,15 @@ async function validateSkillReferences(codexSkillsDir) {
   return { count, samples };
 }
 async function syncWithCodex(targetDir) {
-  const codexHome = path10.resolve(targetDir, ".codex");
-  const codexSkillsDir = path10.join(codexHome, "skills");
-  const codexCommandsDir = path10.join(codexSkillsDir, "claude-commands");
-  const codexInstructionsDir = path10.join(codexHome, "instructions");
-  await fs8.ensureDir(codexSkillsDir);
-  const claudeRootDir = path10.join(targetDir, ".claude");
-  const claudeSkillsDir = path10.join(claudeRootDir, "skills");
-  const claudeCommandsDir = path10.join(claudeRootDir, "commands");
-  const claudeInstructionsDir = path10.join(claudeRootDir, "instructions");
+  const codexHome = path11.resolve(targetDir, ".codex");
+  const codexSkillsDir = path11.join(codexHome, "skills");
+  const codexCommandsDir = path11.join(codexSkillsDir, "claude-commands");
+  const codexInstructionsDir = path11.join(codexHome, "instructions");
+  await fs9.ensureDir(codexSkillsDir);
+  const claudeRootDir = path11.join(targetDir, ".claude");
+  const claudeSkillsDir = path11.join(claudeRootDir, "skills");
+  const claudeCommandsDir = path11.join(claudeRootDir, "commands");
+  const claudeInstructionsDir = path11.join(claudeRootDir, "instructions");
   const syncedSkills = await syncSkills(claudeSkillsDir, codexSkillsDir);
   const syncedInstructions = await syncInstructions(
     claudeInstructionsDir,
@@ -1393,7 +1428,7 @@ var TEMPLATE_DESCRIPTIONS = {
 };
 async function validateTargetDirectory(targetDir) {
   try {
-    const stat = await fs9.stat(targetDir);
+    const stat = await fs10.stat(targetDir);
     if (!stat.isDirectory()) {
       logger.error(`Target is not a directory: ${targetDir}`);
       process.exit(1);
@@ -1407,7 +1442,7 @@ async function validateTargetDirectory(targetDir) {
     process.exit(1);
   }
   try {
-    await fs9.access(targetDir, fs9.constants.W_OK);
+    await fs10.access(targetDir, fs10.constants.W_OK);
   } catch {
     logger.error(`No write permission for: ${targetDir}`);
     process.exit(1);
@@ -1596,7 +1631,7 @@ var init = async (options) => {
     hasHooks,
     scope
   );
-  const codexSyncPath = path11.join(targetDir, ".codex");
+  const codexSyncPath = path12.join(targetDir, ".codex");
   const { syncCodex } = await promptCodexSync({
     providedSyncCodex: options.syncCodex,
     codexPath: codexSyncPath
@@ -1632,8 +1667,8 @@ var init = async (options) => {
             `Codex skill reference issues found: ${result.referenceIssueCount} (showing up to ${result.referenceIssueSamples.length})`
           );
           for (const issue of result.referenceIssueSamples) {
-            const skillPath = path11.relative(targetDir, issue.skillPath);
-            const resolvedPath = path11.relative(targetDir, issue.resolvedPath);
+            const skillPath = path12.relative(targetDir, issue.skillPath);
+            const resolvedPath = path12.relative(targetDir, issue.resolvedPath);
             logger.step(
               `${skillPath} -> @${issue.reference} (missing: ${resolvedPath})`
             );
@@ -1659,7 +1694,7 @@ var init = async (options) => {
 
 // src/index.ts
 var program = new Command();
-program.name("claude-code").description("Claude Code documentation installer for projects").version("0.7.11");
+program.name("claude-code").description("Claude Code documentation installer for projects").version("0.7.12");
 program.option(
   "-t, --template <names>",
   "template names (comma-separated: tanstack-start,hono)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kood/claude-code",
-  "version": "0.7.11",
+  "version": "0.7.12",
   "description": "Claude Code documentation installer for projects",
   "type": "module",
   "bin": "./dist/index.js",

package/templates/.claude/agents/codex.md

@@ -1,44 +1,41 @@
 ---
 name: codex
 description: OpenAI Codex MCP 연동 에이전트. 꼼꼼한 구현, 코드 리뷰, 엣지케이스 검증 담당. Agent Teams에서 Team Lead 역할 우선.
-tools: Read, Write, Edit, Grep, Glob, Bash, mcp__codex__codex, mcp__codex__codex_reply
+tools: Read, Write, Edit, Grep, Glob, Bash, mcp__codex__codex, mcp__codex__codex_reply, mcp__codex__codex_review
 model: sonnet
 permissionMode: default
 maxTurns: 50
 ---
 
-@../../instructions/agent-patterns/parallel-execution.md
-@../../instructions/agent-patterns/read-parallelization.md
 @../../instructions/agent-patterns/agent-teams-usage.md
 @../../instructions/validation/forbidden-patterns.md
 @../../instructions/validation/required-behaviors.md
 
 # Codex Agent
 
-codex-mcp 서버로 OpenAI Responses API 호출. Claude와 페어 프로그래밍.
+codex-mcp로 Codex CLI 호출. Claude와 페어 프로그래밍.
 
-**역할:** Agent Teams **Team Lead** (기본), 구현, 리뷰, 테스트, 디버깅
+**역할:** Agent Teams **Team Lead**, 구현, 리뷰, 테스트
 
 ---
 
 <team_lead>
 
-## Team Lead
+## Team Lead 역할
 
 | 역할 | 이유 |
 |------|------|
-| 태스크 분해 | 꼼꼼한 분할, 누락 방지 |
-| 품질 게이트 | 코드 품질/테스트 검증 |
-| 진행 관리 | 병목 감지 |
+| 태스크 분해 | 꼼꼼한 분할 |
+| 품질 게이트 | 코드/테스트 검증 |
 | 충돌 조율 | 파일 충돌 방지 |
 
 ```typescript
 TeamCreate({ team_name: "project", agent_type: "codex" })
-Task({ subagent_type: 'implementation-executor', team_name: 'project', name: 'claude-impl', prompt: '...' })
+Task({ subagent_type: 'implementation-executor', team_name: 'project', name: 'impl', prompt: '...' })
 // 품질 검증
-mcp__codex__codex_reply({ thread_id: "...", prompt: "코드 리뷰: 보안, 성능, 엣지케이스" })
+mcp__codex__codex_review({ uncommitted: true })
 // 정리
-SendMessage({ type: 'shutdown_request', recipient: 'claude-impl' })
+SendMessage({ type: 'shutdown_request', recipient: 'impl' })
 TeamDelete()
 ```
 
@@ -46,43 +43,28 @@ TeamDelete()
 
 ---
 
-<codex_mcp_usage>
+<tools>
 
 ## MCP 도구
 
-**인증:** Codex CLI OAuth (`~/.codex/auth.json`), 토큰 자동 갱신
-
-### 새 태스크
-
-```typescript
-mcp__codex__codex({
-  prompt: "구현 요구사항 + 품질 기준",
-  working_directory: "/path/to/project",
-  model: "gpt-5.3-codex high"  // 선택 (세션에 저장, 생략 시 Codex CLI 기본값)
-})
-// → JSON { thread_id, result }
-```
-
-**에이전트 루프:** `read_file`, `write_file`, `list_files`, `shell_exec` 자율 호출
-
-### 세션 이어가기
+| 도구 | 용도 |
+|------|------|
+| `codex` | 새 태스크 (세션 생성) |
+| `codex_reply` | 멀티턴 대화 |
+| `codex_review` | 코드 리뷰 (uncommitted/branch/commit) |
 
 ```typescript
-mcp__codex__codex_reply({
-  thread_id: "이전 thread_id",
-  prompt: "후속 지시"
-})
-// 세션 모델 자동 유지, 이전 컨텍스트 보존
-```
+// 구현
+const r = mcp__codex__codex({ prompt: "기능 구현", working_directory: cwd })
 
-### 리뷰 패턴
+// 후속 작업
+mcp__codex__codex_reply({ thread_id: r.thread_id, prompt: "테스트 추가" })
 
-```typescript
-const r = mcp__codex__codex({ prompt: "src/auth/ 분석", working_directory: cwd })
-mcp__codex__codex_reply({ thread_id: r.thread_id, prompt: "보안, 엣지케이스, 성능 리뷰" })
+// 리뷰
+mcp__codex__codex_review({ uncommitted: true })
 ```
 
-</codex_mcp_usage>
+</tools>
 
 ---
 
@@ -90,54 +72,32 @@ mcp__codex__codex_reply({ thread_id: r.thread_id, prompt: "보안, 엣지케이
 
 ## 작업 흐름
 
-**구현:** Read(파일 파악) → codex(구현) → Bash(테스트) → Edit(미세 조정)
+**구현:** Read → codex → Bash(테스트) → Edit(미세 조정)
 
-**리뷰:** Bash(git diff) → codex(diff 분석) → codex_reply(리뷰) → 치명적/경고/제안 분류
-
-**설계 구현:** Read(설계 문서) → codex(설계 기반 구현) → Bash(typecheck + test)
+**리뷰:** codex_review → 치명적/경고/제안 분류
 
 </workflow>
 
 ---
 
-<collaboration>
-
-## Claude 협업
-
-| 상황 | Codex 역할 |
-|------|-----------|
-| Claude 설계 후 | 구현 + 엣지케이스 추가 |
-| Claude 구현 후 | 리뷰 + 개선 제안 |
-| 병렬 작업 | 백엔드/테스트/리뷰 |
-| 의견 분기 | 꼼꼼한 관점 제시, 최종 결정은 사용자 |
-
-</collaboration>
-
----
-
 <rules>
 
-## 필수 / 금지
-
 | 필수 | 금지 |
 |------|------|
-| codex 또는 codex_reply 사용 | MCP 없이 시뮬레이션 |
-| 구현 후 테스트 실행 | 테스트 없이 완료 선언 |
-| 모든 경계 조건 처리 | Claude 영역 침범 |
-| 구조화된 결과 보고 | 충돌 시 임의 결정 |
+| codex MCP 도구 사용 | MCP 없이 시뮬레이션 |
+| 구현 후 테스트 실행 | 테스트 없이 완료 |
+| 경계 조건 처리 | Claude 영역 침범 |
 
 </rules>
 
 ---
 
-<error_handling>
+<errors>
 
 | 에러 | 대응 |
 |------|------|
-| MCP 연결 실패 | 설정 → OpenAI/Codex 등록 안내 |
-| 401 | `codex auth login` 안내 |
-| 타임아웃 | 재시도 |
+| 401 | `codex login` 안내 |
 | 세션 not found | 새 codex 세션 |
-| 동시 요청 에러 | 이전 요청 완료 대기 |
+| 동시 요청 | 이전 요청 완료 대기 |
 
-</error_handling>
+</errors>

package/templates/.claude/commands/git-all.md

@@ -14,11 +14,11 @@ description: 모든 변경사항 커밋 후 푸시
 
 | 스크립트 | 용도 |
 |----------|------|
-| `.claude/scripts/git/git-info.sh` | 상태 + diff 요약 출력 |
-| `.claude/scripts/git/git-commit.sh "msg" [files]` | Co-Authored-By 포함 커밋 |
-| `.claude/scripts/git/git-push.sh` | 안전한 푸시 |
-| `.claude/scripts/git/git-all.sh "msg"` | add all + commit + push (단순 케이스) |
-| `.claude/scripts/git/git-clean-check.sh` | clean 여부 확인 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-info.sh` | 상태 + diff 요약 출력 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "msg" [files]` | Co-Authored-By 포함 커밋 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-push.sh` | 안전한 푸시 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-all.sh "msg"` | add all + commit + push (단순 케이스) |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-clean-check.sh` | clean 여부 확인 |
 
 </scripts>
 
@@ -32,25 +32,25 @@ description: 모든 변경사항 커밋 후 푸시
 
 ```bash
 # 1. 상태 확인
-.claude/scripts/git/git-info.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-info.sh
 
 # 2. 모든 변경사항 커밋 + 푸시
-.claude/scripts/git/git-all.sh "feat: 기능 추가"
+${CLAUDE_SCRIPTS_ROOT}/git/git-all.sh "feat: 기능 추가"
 ```
 
 ### 복잡한 케이스 (논리적 분리 필요)
 
 ```bash
 # 1. 상태 확인
-.claude/scripts/git/git-info.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-info.sh
 
 # 2. 그룹별 커밋
-.claude/scripts/git/git-commit.sh "feat: A 기능" src/a.ts src/a.test.ts
-.claude/scripts/git/git-commit.sh "fix: B 버그 수정" src/b.ts
+${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "feat: A 기능" src/a.ts src/a.test.ts
+${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "fix: B 버그 수정" src/b.ts
 
 # 3. clean 확인 후 푸시
-.claude/scripts/git/git-clean-check.sh
-.claude/scripts/git/git-push.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-clean-check.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-push.sh
 ```
 
 </workflow>

package/templates/.claude/commands/git-merge.md

@@ -15,7 +15,7 @@ argument-hint: <target-branch> <source-branch>
 
 | 스크립트 | 용도 |
 |----------|------|
-| `.claude/scripts/git/git-merge.sh <target> <source>` | checkout → merge → push → 원래 브랜치 복귀 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-merge.sh <target> <source>` | checkout → merge → push → 원래 브랜치 복귀 |
 
 </scripts>
 
@@ -27,7 +27,7 @@ argument-hint: <target-branch> <source-branch>
 
 ```bash
 # 인자에서 타겟/소스 브랜치 추출 후 실행
-.claude/scripts/git/git-merge.sh <target-branch> <source-branch>
+${CLAUDE_SCRIPTS_ROOT}/git/git-merge.sh <target-branch> <source-branch>
 ```
 
 **스크립트 동작:**
@@ -46,10 +46,10 @@ argument-hint: <target-branch> <source-branch>
 
 ```bash
 # deploy/prod에 dev 머지
-.claude/scripts/git/git-merge.sh deploy/prod dev
+${CLAUDE_SCRIPTS_ROOT}/git/git-merge.sh deploy/prod dev
 
 # main에 feature/auth 머지
-.claude/scripts/git/git-merge.sh main feature/auth
+${CLAUDE_SCRIPTS_ROOT}/git/git-merge.sh main feature/auth
 ```
 
 </examples>

package/templates/.claude/commands/git-session.md

@@ -14,10 +14,10 @@ description: 현재 세션에서 수정한 파일만 커밋 후 푸시
 
 | 스크립트 | 용도 |
 |----------|------|
-| `.claude/scripts/git/git-info.sh` | 상태 + diff 요약 출력 |
-| `.claude/scripts/git/git-commit.sh "msg" [files]` | Co-Authored-By 포함 커밋 |
-| `.claude/scripts/git/git-push.sh` | 안전한 푸시 |
-| `.claude/scripts/git/git-clean-check.sh` | clean 여부 확인 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-info.sh` | 상태 + diff 요약 출력 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "msg" [files]` | Co-Authored-By 포함 커밋 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-push.sh` | 안전한 푸시 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-clean-check.sh` | clean 여부 확인 |
 
 </scripts>
 
@@ -29,13 +29,13 @@ description: 현재 세션에서 수정한 파일만 커밋 후 푸시
 
 ```bash
 # 1. 상태 확인
-.claude/scripts/git/git-info.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-info.sh
 
 # 2. 현재 세션 파일만 선택하여 커밋
-.claude/scripts/git/git-commit.sh "feat: 로그인 기능" src/auth/login.ts src/auth/logout.ts
+${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "feat: 로그인 기능" src/auth/login.ts src/auth/logout.ts
 
 # 3. 푸시
-.claude/scripts/git/git-push.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-push.sh
 ```
 
 </workflow>
@@ -70,14 +70,14 @@ description: 현재 세션에서 수정한 파일만 커밋 후 푸시
 ```bash
 # 상황: 로그인 기능 작업 중, 이전 프로필 기능은 미완성
 
-.claude/scripts/git/git-info.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-info.sh
 # modified: src/auth/login.ts (현재 세션)
 # modified: src/auth/logout.ts (현재 세션)
 # modified: src/profile/edit.ts (이전 세션)
 
 # ✅ 로그인 관련만 커밋
-.claude/scripts/git/git-commit.sh "feat: 로그인/로그아웃 기능 추가" src/auth/login.ts src/auth/logout.ts
-.claude/scripts/git/git-push.sh
+${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "feat: 로그인/로그아웃 기능 추가" src/auth/login.ts src/auth/logout.ts
+${CLAUDE_SCRIPTS_ROOT}/git/git-push.sh
 ```
 
 </example>

package/templates/.claude/commands/lint-fix.md

@@ -16,8 +16,8 @@ argument-hint: [파일/디렉토리 경로...]
 
 | 스크립트 | 용도 |
 |----------|------|
-| `.claude/scripts/lint/lint-check.sh` | tsc + eslint 병렬 검사 |
-| `.claude/scripts/lint/lint-file.sh [files]` | 특정 파일만 검사 |
+| `${CLAUDE_SCRIPTS_ROOT}/lint/lint-check.sh` | tsc + eslint 병렬 검사 |
+| `${CLAUDE_SCRIPTS_ROOT}/lint/lint-file.sh [files]` | 특정 파일만 검사 |
 
 </scripts>
 
@@ -31,17 +31,17 @@ argument-hint: [파일/디렉토리 경로...]
 
 ```bash
 # 1. 병렬 검사 (tsc + eslint 동시)
-.claude/scripts/lint/lint-check.sh
+${CLAUDE_SCRIPTS_ROOT}/lint/lint-check.sh
 
 # 2. 오류 수정 후 재검사
-.claude/scripts/lint/lint-check.sh
+${CLAUDE_SCRIPTS_ROOT}/lint/lint-check.sh
 ```
 
 ### 특정 파일 검사
 
 ```bash
 # 특정 파일만
-.claude/scripts/lint/lint-file.sh src/utils/api.ts src/components/Button.tsx
+${CLAUDE_SCRIPTS_ROOT}/lint/lint-file.sh src/utils/api.ts src/components/Button.tsx
 ```
 
 </workflow>

package/templates/.claude/commands/pre-deploy.md

@@ -16,10 +16,10 @@ argument-hint: [파일/디렉토리 경로...]
 
 | 스크립트 | 용도 |
 |----------|------|
-| `.claude/scripts/deploy/deploy-check.sh` | 전체 검증 (tsc + eslint + build) |
-| `.claude/scripts/deploy/build-run.sh` | build만 실행 |
-| `.claude/scripts/lint/lint-check.sh` | tsc + eslint 병렬 검사 |
-| `.claude/scripts/pm/pm-detect.sh` | package manager 감지 |
+| `${CLAUDE_SCRIPTS_ROOT}/deploy/deploy-check.sh` | 전체 검증 (tsc + eslint + build) |
+| `${CLAUDE_SCRIPTS_ROOT}/deploy/build-run.sh` | build만 실행 |
+| `${CLAUDE_SCRIPTS_ROOT}/lint/lint-check.sh` | tsc + eslint 병렬 검사 |
+| `${CLAUDE_SCRIPTS_ROOT}/pm/pm-detect.sh` | package manager 감지 |
 
 </scripts>
 
@@ -33,17 +33,17 @@ argument-hint: [파일/디렉토리 경로...]
 
 ```bash
 # 한 번에 tsc + eslint + build 검증
-.claude/scripts/deploy/deploy-check.sh
+${CLAUDE_SCRIPTS_ROOT}/deploy/deploy-check.sh
 ```
 
 ### 단계별 검증
 
 ```bash
 # 1. lint 검사
-.claude/scripts/lint/lint-check.sh
+${CLAUDE_SCRIPTS_ROOT}/lint/lint-check.sh
 
 # 2. 오류 수정 후 build
-.claude/scripts/deploy/build-run.sh
+${CLAUDE_SCRIPTS_ROOT}/deploy/build-run.sh
 ```
 
 </workflow>

package/templates/.claude/commands/ralph-loop.md

@@ -1,7 +1,7 @@
 ---
 description: "Start Ralph Loop in current session"
 argument-hint: "PROMPT [--max-iterations N] [--completion-promise TEXT]"
-allowed-tools: ["Bash(.claude/scripts/setup-ralph-loop.sh:*)"]
+allowed-tools: ["Bash(${CLAUDE_SCRIPTS_ROOT}/setup-ralph-loop.sh:*)"]
 hide-from-slash-command-tool: "true"
 ---
 
@@ -10,7 +10,7 @@ hide-from-slash-command-tool: "true"
 Execute the setup script to initialize the Ralph loop:
 
 ```!
-".claude/scripts/setup-ralph-loop.sh" $ARGUMENTS
+"${CLAUDE_SCRIPTS_ROOT}/setup-ralph-loop.sh" $ARGUMENTS
 ```
 
 Please work on the task. When you try to exit, the Ralph loop will feed the SAME PROMPT back to you for the next iteration. You'll see your previous work in files and git history, allowing you to iterate and improve.

package/templates/.claude/commands/version-update.md

@@ -18,10 +18,10 @@ argument-hint: <new-version | +1 | +minor | +major>
 
 | 스크립트 | 용도 |
 |----------|------|
-| `.claude/scripts/version/version-find.sh` | 버전 파일 탐색 (package.json + .version()) |
-| `.claude/scripts/version/version-bump.sh <current> <type>` | 새 버전 계산 |
-| `.claude/scripts/git/git-commit.sh "msg" [files]` | 커밋 |
-| `.claude/scripts/git/git-push.sh` | 푸시 |
+| `${CLAUDE_SCRIPTS_ROOT}/version/version-find.sh` | 버전 파일 탐색 (package.json + .version()) |
+| `${CLAUDE_SCRIPTS_ROOT}/version/version-bump.sh <current> <type>` | 새 버전 계산 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "msg" [files]` | 커밋 |
+| `${CLAUDE_SCRIPTS_ROOT}/git/git-push.sh` | 푸시 |
 
 </scripts>
 
@@ -46,18 +46,18 @@ argument-hint: <new-version | +1 | +minor | +major>
 
 ```bash
 # 1. 버전 파일 탐색
-.claude/scripts/version/version-find.sh
+${CLAUDE_SCRIPTS_ROOT}/version/version-find.sh
 
 # 2. 현재 버전 확인 (package.json 읽기)
 
 # 3. 새 버전 계산
-.claude/scripts/version/version-bump.sh 1.2.3 +1
+${CLAUDE_SCRIPTS_ROOT}/version/version-bump.sh 1.2.3 +1
 # → 1.2.4
 
 # 4. 모든 파일 Edit로 업데이트
 
 # 5. 커밋
-.claude/scripts/git/git-commit.sh "chore: 버전 1.2.4로 업데이트" package.json packages/*/package.json
+${CLAUDE_SCRIPTS_ROOT}/git/git-commit.sh "chore: 버전 1.2.4로 업데이트" package.json packages/*/package.json
 ```
 
 </workflow>

package/templates/.claude/hooks/session-env-setup.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# Session Environment Setup Hook
+# Sets CLAUDE_SCRIPTS_ROOT based on where the command/skill is located
+# - User scope (~/.claude/): CLAUDE_SCRIPTS_ROOT=~/.claude/scripts
+# - Project scope (.claude/): CLAUDE_SCRIPTS_ROOT=.claude/scripts
+
+set -euo pipefail
+
+# Only run for SessionStart events
+# The hook receives JSON input via stdin, but for SessionStart we just need to set env vars
+
+# Determine the scripts root based on installation scope
+# Check if user-level .claude exists and has scripts
+USER_SCRIPTS_DIR="$HOME/.claude/scripts"
+PROJECT_SCRIPTS_DIR=".claude/scripts"
+
+# Priority: Project scope first (if exists), then User scope
+if [[ -d "$PROJECT_SCRIPTS_DIR" ]]; then
+  SCRIPTS_ROOT="$PROJECT_SCRIPTS_DIR"
+elif [[ -d "$USER_SCRIPTS_DIR" ]]; then
+  SCRIPTS_ROOT="$USER_SCRIPTS_DIR"
+else
+  # Fallback to project scope (default)
+  SCRIPTS_ROOT="$PROJECT_SCRIPTS_DIR"
+fi
+
+# Write to CLAUDE_ENV_FILE (session-wide environment)
+if [[ -n "${CLAUDE_ENV_FILE:-}" ]]; then
+  echo "CLAUDE_SCRIPTS_ROOT=$SCRIPTS_ROOT" >> "$CLAUDE_ENV_FILE"
+fi
+
+exit 0

package/templates/.claude/scripts/agent-teams/check-availability.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # Agent Teams 사용 가능 여부 확인
-# Usage: .claude/scripts/agent-teams/check-availability.sh
+# Usage: ${CLAUDE_SCRIPTS_ROOT}/agent-teams/check-availability.sh
 
 set -e
 

package/templates/.claude/scripts/agent-teams/setup-tmux.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # Agent Teams용 tmux 환경 세팅
-# Usage: .claude/scripts/agent-teams/setup-tmux.sh
+# Usage: ${CLAUDE_SCRIPTS_ROOT}/agent-teams/setup-tmux.sh
 
 set -e
 

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

@@ -1,104 +1,100 @@
 ---
 name: codex
-description: Claude와 OpenAI Codex 페어 프로그래밍. 자체 codex-mcp 서버로 자유 협업. Claude(창의적) + Codex(꼼꼼함) 강점 활용.
+description: Claude와 OpenAI Codex 페어 프로그래밍. 자유 협업으로 복잡한 작업을 분업 처리. Claude(창의적) + Codex(꼼꼼함) 강점 활용.
 user-invocable: true
 ---
 
 @../../instructions/workflow-patterns/sequential-thinking.md
-@../../instructions/agent-patterns/parallel-execution.md
-@../../instructions/agent-patterns/model-routing.md
 @../../instructions/agent-patterns/agent-teams-usage.md
 @../../instructions/validation/forbidden-patterns.md
 @../../instructions/validation/required-behaviors.md
 
-# Codex Pair Programming Skill
+# Codex Pair Programming
 
-> Claude + codex-mcp 페어 프로그래밍. Claude(설계/창의) + Codex(구현/검증) 역할 분담.
+> Claude + Codex CLI 페어 프로그래밍. codex-mcp 서버가 Codex CLI를 래핑.
 
 ---
 
 <overview>
 
-**codex-mcp 서버:** Rust MCP 바이너리 → OpenAI Responses API 직접 호출
+**codex-mcp:** Codex CLI 래퍼 MCP 서버 (Rust)
 
 | 특성 | 상세 |
 |------|------|
-| **인증** | Codex CLI OAuth (`~/.codex/auth.json`), 토큰 자동 갱신, 401시 강제 갱신+재시도 |
-| **에이전트 루프** | `read_file`, `write_file`, `list_files`, `shell_exec` 자율 실행 |
-| **세션** | `thread_id` 기반 컨텍스트 유지, 모델 세션간 자동 보존 |
-| **보안** | 경로순회 방지, 프로세스그룹 격리, 동시요청 방지 |
+| **인증** | Codex CLI OAuth (`codex login`) |
+| **세션** | `thread_id` 기반 멀티턴, cwd/model 세션간 보존 |
+| **도구** | `codex`, `codex_reply`, `codex_review`, `list_sessions`, `ping` |
 
 </overview>
 
 ---
 
-<prerequisites>
+<setup>
 
-## 사전 요구사항
+## 설정
 
 ```bash
-# 1. Codex CLI OAuth 로그인
-codex auth login
+# Codex CLI 로그인
+codex login
 
-# 2. 빌드 + Claude Code 등록
-cargo build -p codex-mcp --release
-claude mcp add -s user codex -- /path/to/target/release/codex-mcp
+# codex-mcp 등록 확인
+# 앱 설정 → OpenAI / Codex 탭 → 등록 버튼
 ```
 
-또는 앱 설정 → **OpenAI / Codex** 탭 → **등록** 버튼.
-
-**인증:** `~/.codex/auth.json` (OAuth 토큰, 자동 갱신)
-
-</prerequisites>
+</setup>
 
 ---
 
-<codex_mcp_tools>
+<tools>
 
 ## MCP 도구
 
-### mcp__codex__codex — 새 태스크
+### codex — 새 태스크
 
 ```typescript
 mcp__codex__codex({
   prompt: "작업 지시",
-  working_directory: "/path/to/project",
-  model: "gpt-5.3-codex high"  // 선택 (세션에 저장, 생략 시 Codex CLI 기본값)
+  working_directory: "/path/to/project",  // 선택
+  session_id: "my-session",               // 선택 (멀티턴용)
+  model: "gpt-5.3-codex",                 // 선택
+  reasoning_effort: "high"                // 선택: none|minimal|low|medium|high|xhigh
 })
-// → JSON { thread_id, result }
+// → { thread_id, result }
 ```
 
-### mcp__codex__codex_reply — 세션 이어가기
+### codex_reply — 세션 이어가기
 
 ```typescript
 mcp__codex__codex_reply({
   thread_id: "이전 thread_id",
-  prompt: "후속 지시 또는 리뷰 요청"
+  prompt: "후속 지시"
 })
-// → JSON { thread_id, result }
-// 세션 모델 자동 유지
+// 세션 cwd/model 자동 유지
 ```
 
-### 리뷰 패턴 (2단계)
+### codex_review — 코드 리뷰
 
 ```typescript
-// 1단계: 분석
-const r = mcp__codex__codex({
-  prompt: "src/auth/ 코드 읽고 분석해줘",
-  working_directory: cwd
-})
-// 2단계: 리뷰
-mcp__codex__codex_reply({
-  thread_id: r.thread_id,
-  prompt: "보안, 성능, 엣지케이스 리뷰"
+mcp__codex__codex_review({
+  working_directory: "/path/to/project",
+  uncommitted: true,    // 기본값
+  base: "main",         // 선택: 비교 브랜치
+  commit: "abc123"      // 선택: 특정 커밋
 })
 ```
 
-</codex_mcp_tools>
+### list_sessions / ping
+
+```typescript
+mcp__codex__list_sessions()  // 활성 세션 목록
+mcp__codex__ping()           // 헬스체크
+```
+
+</tools>
 
 ---
 
-<collaboration_modes>
+<collaboration>
 
 ## 협업 모드
 
@@ -107,56 +103,50 @@ mcp__codex__codex_reply({
 | **Solo+Review** | 1-2 파일 | 구현 | 리뷰 |
 | **Sequential** | 설계→구현 | 아키텍처 | 구현+테스트 |
 | **Parallel** | 독립 작업 | 창의적 부분 | 꼼꼼한 부분 |
-| **Discussion** | 트레이드오프 | 관점 A | 관점 B |
-| **Teams** | 6+ 파일 | 팀원 | **Team Lead** |
 
-**모드 선택:** sequentialthinking으로 복잡도 판단 → 자동 선택
-
-</collaboration_modes>
+</collaboration>
 
 ---
 
-<workflow>
-
-## 실행 흐름
+<patterns>
 
-| Phase | 작업 |
-|-------|------|
-| **0** | MCP 가용 확인 + 복잡도 분석 |
-| **1** | 협업 모드 결정 |
-| **2** | 역할 분담 (TodoWrite) |
-| **3** | 협업 실행 (Task codex agent + 직접 작업) |
-| **4** | 결과 통합 (충돌 시 AskUserQuestion) |
-| **5** | 검증 + 커밋 |
+## 사용 패턴
 
-### Solo+Review
+### 구현 후 리뷰
 
 ```typescript
-// Claude 구현 → Codex 리뷰
+// Claude가 구현
 Edit/Write → 코드 작성
-const r = mcp__codex__codex({ prompt: "git diff 분석: [diff]", working_directory: cwd })
-mcp__codex__codex_reply({ thread_id: r.thread_id, prompt: "버그, 보안, 엣지케이스 리뷰" })
+
+// Codex가 리뷰
+mcp__codex__codex_review({ uncommitted: true })
 ```
 
-### Sequential
+### 멀티턴 대화
 
 ```typescript
-// Claude 설계 → Codex 구현
-sequentialthinking → 아키텍처
-Task({ subagent_type: 'codex', prompt: `Claude 설계 기반 구현: ${설계문서}` })
+const r = mcp__codex__codex({
+  prompt: "src/auth/ 분석해줘",
+  session_id: "auth-work"
+})
+
+mcp__codex__codex_reply({
+  thread_id: r.thread_id,
+  prompt: "보안 취약점 있어?"
+})
 ```
 
-### Teams (Codex Lead)
+### 설계 → 구현
 
 ```typescript
-TeamCreate({ team_name: "pair-codex", agent_type: "codex" })
-Task({ subagent_type: 'implementation-executor', team_name: 'pair-codex', name: 'claude-impl', prompt: '...' })
-// 완료 후
-SendMessage({ type: 'shutdown_request', recipient: 'claude-impl' })
-TeamDelete()
+// Claude 설계
+sequentialthinking → 아키텍처
+
+// Codex 구현
+Task({ subagent_type: 'codex', prompt: '설계 기반 구현' })
 ```
 
-</workflow>
+</patterns>
 
 ---
 
@@ -164,52 +154,35 @@ TeamDelete()
 
 ## 역할별 강점
 
-| Claude 우선 | Codex 우선 |
-|-------------|-----------|
+| Claude | Codex |
+|--------|-------|
 | 아키텍처 설계 | 정밀 구현 |
 | 창의적 해결책 | 엣지케이스 |
 | 문제 재정의 | 코드 리뷰 |
-| 통합 설계 | 테스트 작성 |
-| 문서화 | 디버깅 |
 
 </strengths>
 
 ---
 
-<validation>
-
-## 검증
-
-**실행 전:** MCP 가용 확인 → Codex 로그인 확인 → 복잡도 분석 → 모드/역할 결정
-**실행 중:** 역할 범위 준수, 파일 충돌 방지 (한 파일 = 한 담당), TodoWrite 추적
-**완료 후:** 결과 통합 → 코드 리뷰 → 테스트 통과 → Teams 정리
-
-</validation>
-
----
-
 <forbidden>
 
 | 금지 | 대안 |
 |------|------|
-| MCP 미설정으로 진행 | 설정 안내 후 중단 |
+| MCP 미설정 상태로 진행 | 설정 안내 후 중단 |
 | 같은 파일 동시 수정 | 작업 범위 분리 |
-| 충돌 시 임의 결정 | AskUserQuestion |
 | Codex 결과 무검증 수용 | 리뷰 + 테스트 |
 
 </forbidden>
 
 ---
 
-<troubleshooting>
+<errors>
 
 | 에러 | 해결 |
 |------|------|
 | MCP 연결 실패 | 앱 설정 → OpenAI/Codex → 등록 |
-| 401 인증 오류 | `codex auth login` |
-| 토큰 갱신 실패 | `codex auth login` 재실행 |
-| 타임아웃 | 재시도 |
+| 401 인증 오류 | `codex login` |
 | 세션 not found | 새 `codex` 세션 시작 |
 | 동시 요청 에러 | 이전 요청 완료 대기 |
 
-</troubleshooting>
+</errors>

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

@@ -534,7 +534,7 @@ const args = parseArguments(ARGUMENTS)
 
 ```bash
 # Agent Teams 가용성 체크
-.claude/scripts/agent-teams/check-availability.sh
+${CLAUDE_SCRIPTS_ROOT}/agent-teams/check-availability.sh
 ```
 
 ### 3. 작업 분석

package/templates/.claude/skills/teams/references/fallback-strategy.md

@@ -32,7 +32,7 @@ fi
 ### 스크립트 사용
 
 ```bash
-.claude/scripts/agent-teams/check-availability.sh
+${CLAUDE_SCRIPTS_ROOT}/agent-teams/check-availability.sh
 ```
 
 </availability_check>