oh-my-customcode 1.1.63 → 1.1.64

package/dist/index.js

@@ -1,47 +1,16 @@
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/utils/fs.ts
-var exports_fs = {};
-__export(exports_fs, {
-  calculateChecksum: () => calculateChecksum,
-  copyDirectory: () => copyDirectory,
-  copyFile: () => copyFile,
-  createTempDir: () => createTempDir,
-  ensureDirectory: () => ensureDirectory,
-  fileExists: () => fileExists,
-  filesAreIdentical: () => filesAreIdentical,
-  getFileStats: () => getFileStats,
-  getPackageRoot: () => getPackageRoot,
-  getRelativePath: () => getRelativePath,
-  isAbsolutePath: () => isAbsolutePath,
-  listFiles: () => listFiles,
-  move: () => move,
-  normalizePath: () => normalizePath,
-  readJsonFile: () => readJsonFile,
-  readTextFile: () => readTextFile,
-  remove: () => remove,
-  resolvePath: () => resolvePath,
-  resolveTemplatePath: () => resolveTemplatePath,
-  validatePreserveFilePath: () => validatePreserveFilePath,
-  writeJsonFile: () => writeJsonFile,
-  writeTextFile: () => writeTextFile
-});
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 function validatePreserveFilePath(filePath, projectRoot) {
@@ -191,15 +160,6 @@ async function writeTextFile(path, content) {
   await ensureDirectory(dirname(path));
   await fs.writeFile(path, content, "utf-8");
 }
-async function remove(path) {
-  const fs = await import("node:fs/promises");
-  const stat = await fs.stat(path);
-  if (stat.isDirectory()) {
-    await fs.rm(path, { recursive: true, force: true });
-  } else {
-    await fs.unlink(path);
-  }
-}
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
@@ -209,45 +169,11 @@ function resolveTemplatePath(relativePath) {
   const packageRoot = getPackageRoot();
   return join(packageRoot, "templates", relativePath);
 }
-async function listFiles(dir, options = {}) {
-  const fs = await import("node:fs/promises");
-  const path = await import("node:path");
-  const files = [];
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory() && options.recursive) {
-      const subFiles = await listFiles(fullPath, options);
-      files.push(...subFiles);
-    } else if (entry.isFile()) {
-      if (!options.pattern || matchesPattern(entry.name, options.pattern)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-async function getFileStats(path) {
-  const fs = await import("node:fs/promises");
-  const stats = await fs.stat(path);
-  return {
-    size: stats.size,
-    created: stats.birthtime,
-    modified: stats.mtime,
-    isDirectory: stats.isDirectory(),
-    isFile: stats.isFile()
-  };
-}
 async function copyFile(src, dest) {
   const fs = await import("node:fs/promises");
   await ensureDirectory(dirname(dest));
   await fs.copyFile(src, dest);
 }
-async function move(src, dest) {
-  const fs = await import("node:fs/promises");
-  await ensureDirectory(dirname(dest));
-  await fs.rename(src, dest);
-}
 async function createTempDir(prefix = "omcustom-") {
   const fs = await import("node:fs/promises");
   const os = await import("node:os");
@@ -257,58 +183,17 @@ async function createTempDir(prefix = "omcustom-") {
   await fs.mkdir(tempDir, { recursive: true });
   return tempDir;
 }
-async function calculateChecksum(path) {
-  const fs = await import("node:fs/promises");
-  const crypto = await import("node:crypto");
-  const content = await fs.readFile(path);
-  const hash = crypto.createHash("md5");
-  hash.update(content);
-  return hash.digest("hex");
-}
-async function filesAreIdentical(path1, path2) {
-  const [checksum1, checksum2] = await Promise.all([
-    calculateChecksum(path1),
-    calculateChecksum(path2)
-  ]);
-  return checksum1 === checksum2;
-}
 function matchesPattern(filename, pattern) {
   const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(filename);
 }
-function getRelativePath(basePath, fullPath) {
-  return relative(basePath, fullPath);
-}
-function normalizePath(inputPath) {
-  return inputPath.replace(/\\/g, "/");
-}
-function isAbsolutePath(inputPath) {
-  return isAbsolute(inputPath);
-}
-function resolvePath(...paths) {
-  return resolve(...paths);
-}
 var init_fs = () => {};
 
 // src/core/registry.ts
-var exports_registry = {};
-__export(exports_registry, {
-  _setRegistryDirForTesting: () => _setRegistryDirForTesting,
-  cleanRegistry: () => cleanRegistry,
-  isTempPath: () => isTempPath,
-  migrateFromLockfiles: () => migrateFromLockfiles,
-  readRegistry: () => readRegistry,
-  registerProject: () => registerProject,
-  registryToList: () => registryToList,
-  unregisterProject: () => unregisterProject
-});
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { basename as basename3, join as join6, resolve as resolve2, sep as sep2 } from "node:path";
-function _setRegistryDirForTesting(dir2) {
-  _registryDirOverride = dir2;
-}
 function isTempPath(projectPath) {
   const normalized = resolve2(projectPath);
   const candidates = new Set;
@@ -353,13 +238,10 @@ async function readRegistryRaw() {
   }
 }
 async function writeRegistry(registry) {
-  const dir2 = registryDir();
-  await mkdir(dir2, { recursive: true });
+  const dir = registryDir();
+  await mkdir(dir, { recursive: true });
   await writeFile(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
 }
-async function readRegistry() {
-  return readRegistryRaw();
-}
 async function registerProject(projectPath, version) {
   const normalizedPath = resolve2(projectPath);
   if (!process.env.OMCUSTOM_REGISTRY_DIR && _registryDirOverride === undefined) {
@@ -376,101 +258,6 @@ async function registerProject(projectPath, version) {
   };
   await writeRegistry(registry);
 }
-async function unregisterProject(projectPath) {
-  const normalizedPath = resolve2(projectPath);
-  const registry = await readRegistryRaw();
-  if (!(normalizedPath in registry.projects))
-    return;
-  delete registry.projects[normalizedPath];
-  await writeRegistry(registry);
-}
-async function cleanRegistry() {
-  const { access: fsAccess } = await import("node:fs/promises");
-  const registry = await readRegistryRaw();
-  const paths = Object.keys(registry.projects);
-  let removed = 0;
-  const purgeTempPaths = !process.env.OMCUSTOM_REGISTRY_DIR && _registryDirOverride === undefined;
-  for (const projectPath of paths) {
-    if (purgeTempPaths && isTempPath(projectPath)) {
-      delete registry.projects[projectPath];
-      removed++;
-      continue;
-    }
-    try {
-      await fsAccess(projectPath);
-    } catch {
-      delete registry.projects[projectPath];
-      removed++;
-    }
-  }
-  if (removed > 0) {
-    await writeRegistry(registry);
-  }
-  return removed;
-}
-async function parseLockFile(lockPath) {
-  try {
-    const content = await readFile(lockPath, "utf-8");
-    const lock = JSON.parse(content);
-    const version = typeof lock.version === "string" ? lock.version : typeof lock.templateVersion === "string" ? lock.templateVersion : "0.0.0";
-    const now = new Date().toISOString();
-    return {
-      version,
-      installedAt: typeof lock.installedAt === "string" ? lock.installedAt : now,
-      updatedAt: typeof lock.updatedAt === "string" ? lock.updatedAt : now
-    };
-  } catch {
-    return null;
-  }
-}
-async function migrateFromLockfiles(searchDirs) {
-  const { readdir: readdir3 } = await import("node:fs/promises");
-  const MAX_DEPTH = 3;
-  const discovered = new Map;
-  async function scan(dir2, depth) {
-    if (depth > MAX_DEPTH || discovered.has(dir2))
-      return;
-    let entries;
-    try {
-      entries = await readdir3(dir2, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    const entry = await parseLockFile(join6(dir2, ".omcustom.lock.json"));
-    if (entry !== null) {
-      discovered.set(resolve2(dir2), entry);
-      return;
-    }
-    if (depth < MAX_DEPTH) {
-      const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SCAN_SKIP_DIRS.has(e.name));
-      await Promise.all(subdirs.map((sub) => scan(join6(dir2, sub.name), depth + 1)));
-    }
-  }
-  await Promise.all(searchDirs.map((dir2) => scan(dir2, 0).catch(() => {})));
-  if (discovered.size === 0)
-    return 0;
-  const registry = await readRegistryRaw();
-  let imported = 0;
-  for (const [projectPath, entry] of discovered) {
-    if (!(projectPath in registry.projects)) {
-      registry.projects[projectPath] = entry;
-      imported++;
-    }
-  }
-  if (imported > 0) {
-    await writeRegistry(registry);
-  }
-  return imported;
-}
-function registryToList(registry) {
-  return Object.entries(registry.projects).map(([path, entry]) => ({
-    name: basename3(path),
-    path,
-    version: entry.version,
-    installedAt: entry.installedAt,
-    updatedAt: entry.updatedAt
-  }));
-}
 var _registryDirOverride, EMPTY_REGISTRY, SCAN_SKIP_DIRS;
 var init_registry = __esm(() => {
   EMPTY_REGISTRY = { projects: {} };
@@ -1167,8 +954,8 @@ var DEFAULT_CRITICAL_DIRECTORIES = ["agent-memory", "agent-memory-local"];
 var PROTECTED_FRAMEWORK_FILES = ["CLAUDE.md", "AGENTS.md"];
 var PROTECTED_RULE_PATTERNS = ["rules/MUST-*.md"];
 function isProtectedFile(relativePath) {
-  const basename2 = relativePath.split("/").pop() ?? "";
-  if (PROTECTED_FRAMEWORK_FILES.includes(basename2)) {
+  const basename = relativePath.split("/").pop() ?? "";
+  if (PROTECTED_FRAMEWORK_FILES.includes(basename)) {
     return true;
   }
   for (const pattern of PROTECTED_RULE_PATTERNS) {
@@ -1847,7 +1634,7 @@ var LOCKFILE_COMPONENTS = [
 ];
 var COMPONENT_PATHS = LOCKFILE_COMPONENTS.map((component) => [getComponentPath(component), component]);
 function computeFileHash(filePath) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
     const stream = createReadStream(filePath);
     stream.on("error", (err) => {
@@ -1857,7 +1644,7 @@ function computeFileHash(filePath) {
       hash.update(chunk);
     });
     stream.on("end", () => {
-      resolve2(hash.digest("hex"));
+      resolve(hash.digest("hex"));
     });
   });
 }
@@ -2096,8 +1883,8 @@ async function handleBackup(targetDir, shouldBackup, result) {
   const rootDir = join5(targetDir, layout.rootDir);
   let preservation = null;
   if (await fileExists(rootDir)) {
-    const { createTempDir: createTempDir2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
-    const tempDir = await createTempDir2("omcustom-preserve-");
+    await Promise.resolve().then(() => init_fs());
+    const tempDir = await createTempDir("omcustom-preserve-");
     preservation = await extractCriticalFiles(rootDir, tempDir);
     if (preservation.extractedFiles.length > 0 || preservation.extractedDirs.length > 0) {
       info("install.preserved", {
@@ -2539,7 +2326,7 @@ var package_default = {
   workspaces: [
     "packages/*"
   ],
-  version: "1.1.63",
+  version: "1.1.64",
   description: "Batteries-included agent harness for Claude Code",
   type: "module",
   bin: {
@@ -2635,8 +2422,8 @@ var isString = (obj) => typeof obj === "string";
 var defer = () => {
   let res;
   let rej;
-  const promise = new Promise((resolve2, reject) => {
-    res = resolve2;
+  const promise = new Promise((resolve, reject) => {
+    res = resolve;
     rej = reject;
   });
   promise.resolve = res;
@@ -3287,13 +3074,13 @@ class Translator extends EventEmitter {
       }
       if (keySeparator) {
         const resTypeIsArray = Array.isArray(resForObjHndl);
-        const copy2 = resTypeIsArray ? [] : {};
+        const copy = resTypeIsArray ? [] : {};
         const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
         for (const m in resForObjHndl) {
           if (Object.prototype.hasOwnProperty.call(resForObjHndl, m)) {
             const deepKey = `${newKeyToUse}${keySeparator}${m}`;
             if (hasDefaultValue && !res) {
-              copy2[m] = this.translate(deepKey, {
+              copy[m] = this.translate(deepKey, {
                 ...opt,
                 defaultValue: shouldHandleAsObject(defaultValue) ? defaultValue[m] : undefined,
                 ...{
@@ -3302,7 +3089,7 @@ class Translator extends EventEmitter {
                 }
               });
             } else {
-              copy2[m] = this.translate(deepKey, {
+              copy[m] = this.translate(deepKey, {
                 ...opt,
                 ...{
                   joinArrays: false,
@@ -3310,11 +3097,11 @@ class Translator extends EventEmitter {
                 }
               });
             }
-            if (copy2[m] === deepKey)
-              copy2[m] = resForObjHndl[m];
+            if (copy[m] === deepKey)
+              copy[m] = resForObjHndl[m];
           }
         }
-        res = copy2;
+        res = copy;
       }
     } else if (handleAsObjectInI18nFormat && isString(joinArrays) && Array.isArray(res)) {
       res = res.join(joinArrays);
@@ -3954,10 +3741,10 @@ class Interpolator {
     let value;
     let clonedOptions;
     const handleHasOptions = (key, inheritedOptions) => {
-      const sep2 = this.nestingOptionsSeparator;
-      if (!key.includes(sep2))
+      const sep = this.nestingOptionsSeparator;
+      if (!key.includes(sep))
         return key;
-      const c = key.split(new RegExp(`${regexEscape(sep2)}[ ]*{`));
+      const c = key.split(new RegExp(`${regexEscape(sep)}[ ]*{`));
       let optionsString = `{${c[1]}`;
       key = c[0];
       optionsString = this.interpolate(optionsString, clonedOptions);
@@ -3975,7 +3762,7 @@ class Interpolator {
           };
       } catch (e) {
         this.logger.warn(`failed parsing options string in nesting for key ${key}`, e);
-        return `${key}${sep2}${optionsString}`;
+        return `${key}${sep}${optionsString}`;
       }
       if (clonedOptions.defaultValue && clonedOptions.defaultValue.includes(this.prefix))
         delete clonedOptions.defaultValue;
@@ -4149,8 +3936,8 @@ class Formatter {
             ...options,
             ...valOptions
           });
-        } catch (error2) {
-          this.logger.warn(error2);
+        } catch (error) {
+          this.logger.warn(error);
         }
         return formatted;
       } else {
@@ -5419,8 +5206,8 @@ function checkAndInstallRtkAfterUpdate() {
 }
 async function updateProjectRegistry(targetDir, newVersion) {
   try {
-    const { registerProject: registerProject2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
-    await registerProject2(targetDir, newVersion);
+    await Promise.resolve().then(() => init_registry());
+    await registerProject(targetDir, newVersion);
   } catch {}
 }
 async function regenerateLockfile(targetDir, result) {
@@ -5527,11 +5314,11 @@ async function checkForUpdates(targetDir) {
 }
 async function applyUpdates(targetDir, updates) {
   const fs = await import("node:fs/promises");
-  for (const update2 of updates) {
-    const fullPath = join7(targetDir, update2.path);
+  for (const update of updates) {
+    const fullPath = join7(targetDir, update.path);
     await ensureDirectory(join7(fullPath, ".."));
-    await fs.writeFile(fullPath, update2.content, "utf-8");
-    debug("update.file_applied", { path: update2.path });
+    await fs.writeFile(fullPath, update.content, "utf-8");
+    debug("update.file_applied", { path: update.path });
   }
 }
 async function preserveCustomizations(targetDir, customizations) {
@@ -5586,8 +5373,8 @@ async function shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile) {
 }
 async function collectProtectedSkipPaths(srcPath, destPath, componentPath, forceOverwriteAll, lockfile, targetDir) {
   if (forceOverwriteAll) {
-    const warnedPaths2 = await findProtectedFilesInDir(srcPath, componentPath);
-    return { skipPaths: [], warnedPaths: warnedPaths2, updatedPaths: [] };
+    const warnedPaths = await findProtectedFilesInDir(srcPath, componentPath);
+    return { skipPaths: [], warnedPaths, updatedPaths: [] };
   }
   const protectedRelative = await findProtectedFilesInDir(srcPath, componentPath);
   const path = await import("node:path");
@@ -5614,9 +5401,9 @@ function isEntryProtected(relPath, componentRelativePrefix) {
   const componentPrefixed = componentRelativePrefix ? `${componentRelativePrefix}/${relPath}` : relPath;
   return isProtectedFile(componentPrefixed);
 }
-async function safeReaddir(dir2, fs) {
+async function safeReaddir(dir, fs) {
   try {
-    return await fs.readdir(dir2, { withFileTypes: true });
+    return await fs.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -5627,11 +5414,11 @@ async function findProtectedFilesInDir(dirPath, componentRelativePrefix) {
   const protected_ = [];
   const queue = [{ dir: dirPath, relDir: "" }];
   while (queue.length > 0) {
-    const { dir: dir2, relDir } = queue.shift();
-    const entries = await safeReaddir(dir2, fs);
+    const { dir, relDir } = queue.shift();
+    const entries = await safeReaddir(dir, fs);
     for (const entry of entries) {
       const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
-      const fullPath = path.join(dir2, entry.name);
+      const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         queue.push({ dir: fullPath, relDir: relPath });
       } else if (entry.isFile() && isEntryProtected(relPath, componentRelativePrefix)) {
@@ -5810,16 +5597,16 @@ async function applyNamespaceSync(targetDir, component, lockfile) {
   const synced = [];
   const queue = [{ dir: srcPath, relDir: "" }];
   while (queue.length > 0) {
-    const { dir: dir2, relDir } = queue.shift();
+    const { dir, relDir } = queue.shift();
     let entries;
     try {
-      entries = await fs.readdir(dir2, { withFileTypes: true });
+      entries = await fs.readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
-      const fullSrcPath = join7(dir2, entry.name);
+      const fullSrcPath = join7(dir, entry.name);
       if (entry.isDirectory()) {
         queue.push({ dir: fullSrcPath, relDir: relPath });
         continue;
@@ -5847,10 +5634,10 @@ async function backupInstallation(targetDir) {
   await ensureDirectory(backupDir);
   const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
-  for (const dir2 of dirsToBackup) {
-    const srcPath = join7(targetDir, dir2);
+  for (const dir of dirsToBackup) {
+    const srcPath = join7(targetDir, dir);
     if (await fileExists(srcPath)) {
-      const destPath = join7(backupDir, dir2);
+      const destPath = join7(backupDir, dir);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.1.63",
+  "version": "1.1.64",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/rules/MAY-optimization.md

@@ -36,6 +36,10 @@
 
 > **v2.1.234+**: macOS/Linux 네이티브 빌드의 내장 `grep`이 pathological pattern에서 메모리 고갈 대신 fail fast하고, `-m N`과 `-A/-C` 옵션을 함께 쓸 때의 context 출력 정확도가 수정되었습니다(v2.1.235에서 추가 보강). 위 「도구 이름 ≠ 그 프로그램」(#1590) 조항과 인접한 함정입니다 — 이 저장소의 Bash 도구 `grep`은 셸 함수로 셰이딩돼 있으므로, 내장 `grep` 자체의 견고성 개선과 셰이딩 문제는 **별개 축**입니다. Darwin(이 저장소 실행 환경) 네이티브 빌드에 해당합니다.
 
+> **v2.1.260/265+**: (260) 여러 세션이 같은 프로젝트 디렉토리를 공유할 때 간헐적으로 발생하던 "task output swap refused" 오류가 수정되었습니다 — 위 v2.1.252 Mac tasks-dir 결함과 **같은 오류 문구의 별개 원인**이므로, v2.1.252~259 환경에서는 이 메시지가 명령 자체의 결함이 아니라 동시 세션 경합에서 나왔을 수 있습니다(R020 Read-Before-Characterize). (260) 서브에이전트가 시작한 background 명령의 1시간 제한이 제거되어, 이제 메인 세션과 동일하게 종료되거나 중지될 때까지 실행됩니다 — 서브에이전트의 장시간 background 빌드가 더 이상 60분에 무음 종료되지 않습니다. (265) 디스크에 저장되는 도구 결과에 1GB 상한이 추가되고 저장 파일이 잘렸을 때 대화 내 미리보기에 그 사실이 표시됩니다 — 저장된 도구 결과 파일을 읽을 때는 이 절단 안내 유무를 먼저 확인한 뒤 완전한 것으로 간주합니다. (265) 비대화형 세션(`-p` + stream-json 입력, Agent SDK, cloud)이 매 사용자 메시지마다 셸 작업 디렉토리를 리셋하던 결함이 수정되어 `cd`가 턴 간 유지됩니다 — 턴마다 `cd`를 재실행하는 우회책을 쓴 `-p` 스크립트는 v2.1.265+에서 그 재실행이 불필요해집니다(무해하지만 제거 가능).
+
+> **v2.1.259/261+**: (259) `claude plugin validate --json`이 기계 판독 가능한 검증 리포트를 제공합니다(cross-ref R017 v2.1.233 `plugin validate` 노트 — 사람 판독용 출력 파싱보다 이 쪽을 우선). (261) `/context`의 토큰 계산이 토큰-계산 API를 쓸 수 없을 때 추가 소형 모델 요청 대신 **로컬 추정치**를 사용하도록 바뀌었습니다 — 엔드포인트가 다운된 동안에는 `/context` 수치가 API 실측이 아니라 추정치일 수 있습니다. (261) `claude -p --resume <file>`이 트랜스크립트에 기록된 손상된 세션 ID를 그대로 채택하던 결함이 수정되어 이제 새 세션 ID로 재개합니다 — 트랜스크립트 기반 계수(R020)에서 v2.1.261+의 재개된 `-p` 세션은 재개 대상 파일과 다른 세션 ID를 가질 수 있습니다.
+
 <!--
 > **v2.1.206+**: `/doctor`에 checked-in CLAUDE.md에서 코드베이스로부터 파생 가능한 내용을 잘라내도록 제안하는 체크가 추가되었습니다 — R005 "Context Optimization via HTML Comments"의 컨텍스트 절감 원칙과 정합(모델 불필요 메타데이터 축소).
 -->

package/templates/.claude/rules/MUST-agent-design.md

@@ -79,10 +79,14 @@ Skill/rule text instructing "spawn with `model: opus`" refers to this tier — a
 
 > **v2.1.257+**: `CLAUDE_CODE_SUBAGENT_MODEL_FORCE`가 신설되어, 설정 시 `CLAUDE_CODE_SUBAGENT_MODEL`(또는 메인 모델)을 **모든** 서브에이전트에 강제 적용하며 per-spawn(Tier 3)과 agent-definition(Tier 1/2) model override를 무시합니다. 즉 위 v2.1.251 노트의 "이 env var가 project의 model pin을 더 이상 깨뜨릴 수 없다"는 서술은 **FORCE 미설정 시에 한해** 참으로 좁혀집니다. FORCE가 설정된 환경에서는 frontmatter의 model이 실행 모델의 증거가 아니므로(R020 "attempt ≠ outcome"의 모델 각도, v2.1.223 강등 경고 노트와 같은 계열) 무인 실행 전 `env | grep -c CLAUDE_CODE_SUBAGENT_MODEL_FORCE`처럼 값 노출 없이 **설정 여부만** 확인합니다.
 
+> **v2.1.259+**: 프론트매터 `model:` 관련 결함 2건이 수정되었습니다 — (a) 커스텀 커맨드와 **스킬**의 프론트매터 `model:`이 interactive 세션에서 **무시**되던 결함이 수정되어, 259 이전에는 이 파일 「Skill Frontmatter」의 선택적 `model` 필드가 interactive 실행에서 **효과가 없었고**, 스킬의 실제 실행 모델은 스킬이 무엇을 선언했든 세션 모델 그대로였습니다(R020 "attempt ≠ outcome"의 스킬 model pin 각도). (b) auto mode가 커맨드·스킬 프론트매터 `model:`이 명명한, 지원하지 않는 모델로 turn을 실행하던 결함이 수정되어 이제 세션 모델을 유지합니다 — 즉 auto mode에서는 스킬 `model:` pin이 세션 모델에 조용히 override될 수 있으므로, 실제 실행 모델은 프론트매터가 아니라 v2.1.223 강등 경고로 확인합니다.
+
 > **Claude Fable 5 (access via CC v2.1.170+)**: Mythos-class model, GA on the Claude API and positioned as a tier above Opus — its capabilities exceed any previously GA model. CC v2.1.170 is the client version that adds access (the model's GA is an API/platform property, not a CC-release milestone). Available via frontmatter full ID `claude-fable-5` (Tier 2) or Agent tool `model: fable` (Tier 3) — NOT via a Tier-1 frontmatter alias. Reserve for the most complex reasoning where its capability premium is warranted; `sonnet` remains the default for general tasks and `opus` for architecture (cost/latency awareness, R005). CC v2.1.170 also fixes session transcripts not saving (and not appearing in `--resume`) when launched from a VS Code integrated terminal or any shell inheriting Claude Code env vars — relevant to transcript-dependent skills (`homework`, `episodic-memory`). Closes #1352.
 
 > **v2.1.257+**: Claude Fable 5.1(`claude-fable-5-1`)이 추가되어 **기본 Fable 모델**이 되었습니다 — 1M context, $10/$50 per Mtok(캐시 읽기 $0.25/Mtok). Tier-3 `model: fable` alias는 이제 Fable 5.1로 해석됩니다(단 Claude apps gateway 세션은 게이트웨이가 아직 Fable 5.1을 미지원해 당분간 Fable 5로 유지됩니다 — `/model`에서 명시 선택해야 Fable 5.1 사용 가능). frontmatter에서 확정하려면 Tier-2 full ID `claude-fable-5-1`을 쓰고, 기존 `claude-fable-5` pin은 그대로 Fable 5에 남습니다 — Tier-1 alias 해석 주체는 CC라는 위 원칙(v2.1.219/222 노트와 동일 계열)의 재확인입니다.
 
+> **v2.1.260+**: Fable 5.1 관련 결함 3건이 수정되고 개선 1건이 적용되었습니다 — `model: fable` 에이전트가 `ANTHROPIC_DEFAULT_FABLE_MODEL` pin에 `[1m]` 태그를 붙여도 이를 무시하고 200K 컨텍스트 창으로 조용히 실행되던 결함(즉 260 이전에는 Fable에 붙인 Tier-2 `[1m]` 접미사가 이 env pin 경로에서 **존중되지 않았습니다**); `/model` 피커가 Fable 5.1을 표시하지 않던 결함(`/model claude-fable-5-1` 직접 입력만 동작); Fable 5.1의 prompt caching이 도구 결과 이후 첨부된 컨텍스트를 커버하지 못해 매 도구-호출 turn마다 uncached 입력으로 재전송되던 결함; 그리고 세션 중 `/effort` 변경이 이제 Fable 5.1의 prompt cache를 무효화하지 않도록 개선되었습니다. 또한 (260) 1M-컨텍스트 모델의 auto-compact가 강화되어 Opus·Fable 세션이 1M-token 한도 직전에 compact하며, 초대형 컨텍스트의 복구 compaction이 10분 타임아웃으로 끊기지 않습니다 — 위 R013 v2.1.251 Sonnet 5 1M auto-compact 노트를 Opus/Fable로 확장합니다(cross-ref R013).
+
 <!-- ARCHIVED CC version notes (historical):
 > **v2.1.173+**: Fable 5 model IDs carrying a `[1m]` suffix are now auto-normalized (the suffix is stripped) because Fable 5 includes 1M context by default. Use `claude-fable-5` / `model: fable` WITHOUT a `[1m]` suffix — appending it is redundant and normalized away. (The `[1m]` suffix remains meaningful for Opus/Sonnet IDs.)
 
@@ -93,6 +97,8 @@ Skill/rule text instructing "spawn with `model: opus`" refers to this tier — a
 
 > **Fable 5 Effort 전략**: Fable 5는 **high effort가 기본값**이며, `xhigh`는 capability-sensitive 작업(최고난도 아키텍처/추론)에 한정해야 합니다. Fable 5의 `low`/`medium` effort조차 이전 세대 모델의 `xhigh`를 상회하는 품질을 보이므로, Fable 5를 사용하는 실행 에이전트는 `effort` 필드를 신중히 명시하고 불필요한 `xhigh` 남용을 지양합니다(R005 비용/지연 인식과 정합).
 
+> **v2.1.267+**: `effort:` 프론트매터 관련 결함·신규 상한 3건 — (a) 커스텀 커맨드·스킬·서브에이전트의 `effort:` 프론트매터가, 기본 effort가 여전히 고정된 모델(Opus 4.7, Opus 4.8, Fable 5)에서 **무시**되던 결함이 수정되었습니다. 즉 267 이전에는 이 파일의 "스킬 `effort`가 에이전트 `effort`보다 우선한다"는 서술과 위 「Fable 5 Effort 전략」의 `effort` 명시 지침이 Fable 5 / Opus 4.8 에이전트에서 **런타임 효과가 없었습니다** — 프론트매터 effort는 실제 실행된 effort의 증거가 아니었습니다. (b) 신규 `maxEffortLevel` 설정(최상위 또는 `modelSettings` 하위 모델별)이 모든 provider에서 effort 레벨 상한을 강제합니다 — 사용자는 여전히 더 낮은 레벨을 선택할 수 있습니다. 이는 프론트매터 `effort`보다 **상위에 위치하는 설정 레벨 상한**이므로, `xhigh`를 선언한 에이전트도 상한이 설정돼 있으면 그 상한에서 실행됩니다(프론트매터로 유추하지 말고 실효 effort를 확인). (c) `/model opusplan[1m]`이 "Model not found"로 거부되던 결함이 265에서 수정되어, `/model` 명령에서 이 표기가 이제 수용됩니다 — 프론트매터 `model: opusplan[1m]` 경로는 릴리즈 노트가 언급하지 않으므로 미실측입니다.
+
 > **Mythos 5 (`claude-mythos-5`)**: Project Glasswing 한정 공급 모델로, **GA가 아닙니다** — Fable 5(GA, 위 "Model Specification — 3 Tiers"의 `claude-fable-5`/`fable`)와 구분해야 합니다. 특성: adaptive-thinking 전용 아키텍처 + 안전 분류기가 개입 시 `stop_reason: "refusal"`로 fallback하는 체계를 가집니다. oh-my-customcode 에이전트 frontmatter에는 아직 alias를 등록하지 않습니다(비-GA, 공급 제한).
 
 > **프롬프팅 패턴 상호참조**: Fable 5/Mythos 5 대상 프롬프팅 패턴(effort 조합, adaptive-thinking 활용, refusal fallback 대응)의 상세 가이드는 `guides/claude-code/16-fable5-prompting.md`를 참조하세요.
@@ -139,6 +145,8 @@ This is a settings-level resilience mechanism, distinct from the per-agent `mode
 
 Key optional fields: `memory`, `effort`, `skills`, `soul`, `isolation`, `background`, `maxTurns`, `maxTokens`, `mcpServers`, `hooks`, `permissionMode`, `disallowedTools`, `limitations`, `domain`, `disableSkillShellExecution`, `experimental.cacheTtl` (v2.1.248+). Supported since CC v2.1.63+. See full optional frontmatter via Read tool.
 
+> **v2.1.261/265/267+**: 서브에이전트/스킬 런타임 관련 3건 — (261) `--append-subagent-system-prompt-file`이 신설되어 커맨드라인에 담기 힘들 만큼 큰 서브에이전트 시스템 프롬프트를 파일에서 읽습니다(R009의 ~5000-token 프롬프트 휴리스틱과 정합 — 대형 프롬프트는 단순 파일 로드가 아니라 우선 분할의 신호입니다). (265) forked 스킬(`context: fork`)이 착수(kickoff) 프롬프트를 스트리밍하지 않고, `--forward-subagent-text`와 함께 쓸 때 그 텍스트 turn을 stream-json progress 이벤트로 내보내지 않던 결함이 수정되었습니다 — 아래 「Context Fork Criteria」의 10/12 `context: fork` 스킬을 `-p --output-format stream-json`으로 실행할 때 관련되며, 구버전에서는 fork progress 이벤트 부재가 fork가 실행되지 않았다는 증거가 아니었습니다. (267) `--system-prompt`/`--append-system-prompt`로 시작한 서브에이전트·세션이 이제 시스템 프롬프트와 도구 정의를 매 요청마다 재렌더링하는 대신 한 번만 기록합니다(prompt-cache 안정성) — `--system-prompt-snapshot off`는 프롬프트 반복 작업을 위해 매 요청 새로 렌더링합니다.
+
 ### Note on `skills:` field
 
 The `skills:` frontmatter field is **advisory metadata** consumed by oh-my-customcode tooling (graph-builder, mgr-sauron) for documentation and validation. It is **NOT a runtime allowlist** — Claude Code does not filter the available skills based on this field, and subagents can invoke any registered skill regardless of what `skills:` declares. Use it to document a subagent's intended skill dependencies; do not rely on it for access control.

package/templates/.claude/rules/MUST-agent-teams.md

@@ -432,6 +432,10 @@ Cross-reference: R020 ("actual outcome ≠ attempt" — verifying that a command
 
 > **v2.1.257+**: 세 건이 함께 수정되었습니다. (a) leader의 mailbox 쓰기가 잠시 잠긴 사이 teammate permission request가 **두 번 응답**되던 결함 수정 — v2.1.224/251 SendMessage·inbox 신뢰성 계열의 연장이며, 구버전에서 승인이 2회 적용된 흔적은 이중 승인 의도의 증거가 아닙니다. (b) tmux/iTerm2 pane의 teammate가 shutdown 확인 후에도 열려 있던 결함 수정 — 위 Lifecycle의 `TeamDelete` 이후 pane 잔존은 더 이상 정상이 아닙니다. (c) `/fork`가 원 대화의 prompt cache를 새 background 세션에서 유지하도록 개선(worktree briefing이 system-prompt 변경 대신 메시지로 도착) — R009 fork 컨텍스트 상속 노트의 비용 각도. 이 저장소는 `TeamCreate` 미등록으로 R018이 dormant이므로 (a)(b)는 기록용, (c)는 fork 사용 시 즉시 해당합니다.
 
+> **v2.1.260+**: `SendMessage`/teams 신뢰성 계열에서 세 건이 추가로 수정되었습니다 — 다른 에이전트를 `SendMessage`로 resume한 서브에이전트가 그 에이전트의 완료 알림을 받지 못하고(알림이 대신 main conversation으로 갔습니다), in-process teammate의 트랜스크립트가 긴 API 재시도 대기(`CLAUDE_CODE_RETRY_WATCHDOG` 등) 중 재시도 알림에 실제 메시지가 덮여 유실되거나 비어 보였으며, background로 이동한 세션이 `ListAgents`에 동일 이름의 "interactive" 유령 쌍둥이로 **두 번** 나타나 뷰어 쪽이 `SendMessage` 전달을 받는 문제가 있었습니다 — 위 v2.1.229 `ListAgents` 노트("열거됐다고 도달 가능하다고 가정하지 않는다")를 확장합니다: 나열된 이름이 단일 실제 대상이라는 보장조차 없었습니다. 결론은 그대로입니다 — 결정론적 ground-truth만이 완료 증거입니다.
+
+> **v2.1.261+**: 다른 머신의 OFFLINE Remote Control 세션으로 `SendMessage`를 보내면 전송됨으로 읽혔으나, 이제 그 머신이 재연결될 때까지 전달이 큐잉된다는 결과를 반환합니다 — v2.1.224 inbox 쓰기 실패·v2.1.251 최종 답변 유실에 이은 이 계열의 세 번째 사례이며, 구버전의 "Message sent"는 상대가 온라인이라는 보장조차 아니었습니다. 같은 릴리즈에서 in-process agent-team teammate가 두 번째 턴에 첫 턴의 도구·스킬 announcement를 재전송해 요청 prefix가 바뀌고 prompt cache를 놓치던 결함도 수정되었고, (265) teammate·resumed 서브에이전트가 `SubagentStart` 훅 컨텍스트와 preloaded skill을 prompt prefix 밖으로 이동시키던 결함도 수정되었습니다. 이 저장소의 R018은 `TeamCreate` 부재로 dormant이므로, 이 노트는 cross-session `SendMessage` 경로에 한해 기록합니다.
+
 <!-- ARCHIVED CC version note (historical):
 > **CC v2.1.162+**: `claude agents --json` now includes a `waitingFor` field showing what a waiting session is blocked on (e.g. a permission prompt). Use it as an additional deterministic ground-truth signal — a member with a non-empty `waitingFor` is blocked on input (needs unblocking), NOT silently stalled (reassign per stall handling below). This distinguishes the two failure modes the verification is meant to separate.
 

package/templates/.claude/rules/MUST-completion-verification.md

@@ -426,6 +426,10 @@ Origin: #1269 ① (R020 self-violation, session 106).
 
 **교훈**: 위 Core Rule("actual outcome ≠ attempt")은 방향이 없다 — 도구가 성공을 보고하든 실패를 보고하든, 보고 자체는 ground-truth가 아니다. 실패 보고를 받았다고 곧바로 재시도·롤백에 들어가지 말고, 먼저 실제 산출물 상태를 확인한다.
 
+> **v2.1.259/261+**: "정지 보고 ≠ 실제 정지" 결함 3건이 수정되었습니다. (259) Stop이 remote-control 세션의 background agent·workflow를 실제로 멈추지 못했던 결함 — 이제 kill된 task는 프로세스가 종료될 때까지 계속 표시되고 재정지 가능합니다. (261) SDK·cloud 세션이 첫 프롬프트 직후, turn이 시작하기 전에 도착한 Stop/interrupt를 무시하고 turn을 끝까지 실행하던 결함이 수정되었습니다. (261) 터미널 진행 표시(iTerm2, Ghostty, ConEmu)가 background workflow/agent가 아직 실행 중인데도 세션을 완료된 것으로 표시하던 결함이 수정되었습니다. 세 건 모두 이 섹션 원칙의 **역방향 쌍둥이**입니다 — "정지됨"/"완료됨" 신호도 ground-truth가 아니므로, 인터럽트가 실제로 적용됐다고 단정하기 전에 프로세스/run 상태(`gh run list`, task 패널, `pgrep`)로 확인합니다. 같은 릴리즈에서 (259) 이전 정지 실행이 종료 중인 상태에서 workflow run을 재개하면 그 에이전트들이 **중복 실행**될 수 있던 결함도 수정되었습니다(cross-ref R023 Workflow resume).
+
+> **v2.1.265/267+**: (265) 이전 프로세스가 도구 실행 중 죽은 뒤 재개하면 마지막 프롬프트를 더 이상 재작성하지 않고, 중단된 도구 호출을 유지하며 **interrupted로 명시 표시**합니다 — 위 v2.1.246 행(인터럽트된 셸 명령이 단순 "실행됨"으로만 표시)의 연장선으로, 이 경로에서는 이제 트랜스크립트에 명시적 interrupted 마커가 남으므로 v2.1.265+에서는 그 부재가 유의미한 증거지만 구버전에서는 아닙니다. (267) `/compact` 또는 다른 슬래시 커맨드 직후 `-p --resume`으로 재개할 때 가짜 "Continue from where you left off." turn이 더 이상 삽입되지 않습니다 — `/fsd` 류 `-p` 루프에서 이런 turn을 사용자 입력으로 오인할 수 있었던 경로와 관련됩니다(R015: 이것은 지시가 아닙니다). 또한 큰 세션(트랜스크립트 5MB 초과)을 재개할 때 병렬 도구 호출과 그 훅 출력이 재로드된 대화에서 누락되던 결함도 수정되었습니다(cross-ref R021) — 회고적 트랜스크립트 계수(「Self-Violation Counting Is Also Diagnosis」)에서, 구버전으로 재개된 5MB 초과 세션은 도구 호출이 유실됐을 수 있으므로 그런 트랜스크립트의 계수는 **하한값**으로 취급합니다.
+
 ### CI Publish-Step Error vs Published-Artifact Ground Truth
 
 > Origin: #1332 — `npm publish --provenance` emitted a Sigstore `TLOG_CREATE_ENTRY_ERROR` 409, but the publish step's `|| npm view <pkg>@<ver>` fallback recovered (the package WAS published) and release.yml succeeded on all jobs. A subagent read the tlog error in the logs and prematurely declared the run "failed", recommending a re-run; deterministic ground-truth (`npm view`, `gh release view`) showed the release had fully succeeded.

package/templates/.claude/rules/MUST-enforcement-policy.md

@@ -47,6 +47,10 @@ oh-my-customcode uses an **advisory-first enforcement model**. Most rules are en
 
 > **v2.1.248+**: 훅 관측성이 두 건 강화되었습니다 — (a) `PermissionRequest`/`PreToolUse` 훅이 유효하지 않은 응답을 출력해 background session이 조용히 대기하던 결함이 수정되어, 이제 `claude agents` 행이 해당 훅 이름과 스키마 에러를 표시합니다. (b) 훅이 stdout으로 낸 `{…}` 객체가 유효한 JSON이 아닐 때 조용히 plain text로 처리하던 결함이 수정되어, 이제 parse 에러와 함께 훅 에러로 보고됩니다. 위 v2.1.214 "훅 stdout JSON이 스키마 검증에 실패할 때 exit code 2가 문서대로 차단하지 못하던 문제" 노트와 같은 계열 — 훅 실패가 무음에서 가시화되는 흐름의 연속입니다.
 
+> **v2.1.259+**: blocking Stop 훅이 발동한 턴의 **다음** 턴이 그 턴의 모델 reasoning을 잃고, 일부 모델에서는 prompt cache까지 miss하던 결함이 수정되었습니다. 이 저장소의 Stop-hook 계층(`session-reflection.sh`, retroactive R007/R008 advisory)에 직접 해당됩니다 — 구버전에서는 Stop 훅의 block이 차단 자체 외에 **숨은 비용**(reasoning 유실 + cache miss)을 수반했으므로, v1.1.53~56에 기록된 "Stop 훅 잠식" 패턴의 **원인 후보 중 하나**로 재해석할 여지가 있습니다. 단 확정 원인은 아니며 가설 후보로만 취급합니다(R020 hypothesis 규율). 같은 릴리즈에서 `claude plugin validate --json`이 기계 판독 가능한 리포트를 제공하게 되었습니다(위 R017 v2.1.233 `plugin validate` 노트의 연장) — Tier-1 결정론적 검사로 활용 가능합니다.
+
+> **v2.1.261/265/267+**: resume 시 훅 컨텍스트 무결성 결함 3건이 수정되었습니다. (261) 세션 재개 시 **병렬 도구 호출 주변**의 훅 출력 등 컨텍스트가 유실되어 재개된 요청이 달라지던 결함이 수정되었습니다. (267) 대용량 세션(트랜스크립트 5MB 초과) 재개 시 병렬 도구 호출과 그 훅 출력이 누락되던 결함이 수정되었습니다. (265) agent teammate와 재개된 서브에이전트가 이후 턴에서 `SubagentStart` 훅 컨텍스트와 preload된 스킬을 prompt prefix 밖으로 이동시켜 prompt-cache 재사용을 깨뜨리던 결함이 수정되었습니다. 함의: 구버전에서 재개된 세션의 대화에 어떤 훅의 출력이 보이지 않는다고 해서 그 훅이 **발화하지 않았다**는 증거는 아닙니다 — 「배선 확인 ≠ 전달 확인 ≠ 발화 확인 ≠ 로드 확인」4층 구분에 5번째 각도(**발화 ≠ 재개 후 보존**)가 추가됩니다. 또한 (267) managed `allowedHttpHookUrls`/`httpHookAllowedEnvVars`가 읽을 수 없을 때 아무것도 허용하지 않도록(fail-closed) 변경되었습니다.
+
 ## Why Advisory-First
 
 1. **Agent flexibility**: Hard blocks can trap agents in unrecoverable states