oh-my-customcode 1.1.62 → 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.62",
+  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.62",
+  "version": "1.1.64",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/hooks/scripts/audit-log.sh

@@ -20,14 +20,34 @@ printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
 # Extract fields from hook input
 tool_name=$(printf '%s\n' "$input" | jq -r '.tool_name // "unknown"')
 file_path=$(printf '%s\n' "$input" | jq -r '.tool_input.file_path? // .tool_input.command? // ""' | head -c 200)
-agent_type=$(printf '%s\n' "$input" | jq -r '.agent_type // "unknown"')
-model=$(printf '%s\n' "$input" | jq -r '.model // "unknown"')
+# Agent identity and model. PostToolUse has NO top-level `model` at all, and its
+# top-level `agent_type` is present only when the hook fires from inside a subagent
+# (CC 2.1.259 schema: "Present when the hook fires from within a subagent") — so on
+# the main thread both reads resolved to "unknown" on every single entry.
+# Measured replacements (#1656 C): the Agent tool's result object carries
+# `resolvedModel` (892 occurrences in this project's transcript corpus, e.g.
+# "claude-sonnet-5" / "claude-opus-5[1m]") and, on the synchronous shape, `agentType`;
+# the spawn arguments carry `subagent_type`.
+# `?` keeps a scalar-shaped tool_input/tool_response from aborting under `set -euo pipefail`.
+agent_type=$(printf '%s\n' "$input" | jq -r '
+  (.agent_type?
+    // .tool_input?.subagent_type?
+    // .tool_response?.agentType?
+    // "unknown") | tostring
+' 2>/dev/null) || agent_type="unknown"
+model=$(printf '%s\n' "$input" | jq -r '
+  (.model?
+    // .tool_response?.resolvedModel?
+    // "unknown") | tostring
+' 2>/dev/null) || model="unknown"
 # Outcome signal. PostToolUse carries the result under `tool_response`, not
 # `tool_output` (measured 2026-09-03: 1764/1764 PostToolUse payloads had
 # `tool_response`, 0/1764 had `tool_output`), so the old `.tool_output.is_error`
 # read was always absent and every entry was logged as outcome=success.
-# Measured failure signals: `.tool_response.is_error` (generic) and
-# `.tool_response.interrupted` (present on every Bash response).
+# Failure signals read below: `.tool_response.is_error` (generic) and
+# `.tool_response.interrupted`. The latter is present on every Bash response but
+# was never observed true in this corpus (0/1555), so it is defensive coverage —
+# not a signal measured to fire.
 # jq's `//` treats both null and false as absent, so this chain is an OR:
 # the result is true iff at least one signal is true.
 is_error=$(printf '%s\n' "$input" | jq -r '

package/templates/.claude/hooks/scripts/failure-ledger.sh

@@ -52,6 +52,9 @@ ts=$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo "")
 #   (r007-r008-drift-advisor.sh의 `.role` vs `.message.role`과 동일 계열).
 #   .tool_error / .tool_response.* fallback은 스키마 변화에 대한 방어로만 남긴다 —
 #   tool_response가 문자열인 경우 인덱싱 에러로 레코드가 통째로 유실되므로 type 검사로 감싼다.
+#   .tool_input도 같은 이유로 type 검사를 씌운다 (#1656 A 실측): 스칼라/배열 tool_input이
+#   오면 jq가 인덱싱 에러로 죽고 `2>/dev/null || true` 때문에 **조용히 레코드 전체가
+#   유실**됐다 — rc는 0이고 stderr도 비어 있어 크래시가 아니라 데이터 손실로 나타난다.
 #
 # 단일 라인(<1KB) append 이므로 O_APPEND 원자성에 기대어 병렬 에이전트 환경에서도 안전.
 printf '%s' "$input" \
@@ -61,7 +64,9 @@ printf '%s' "$input" \
         session: (.session_id // ""),
         cwd:     $cwd,
         tool:    (.tool_name // "unknown"),
-        target:  ((.tool_input.command // .tool_input.file_path // "") | tostring | .[0:160]),
+        target:  ((if (.tool_input | type) == "object"
+                    then (.tool_input.command // .tool_input.file_path // "")
+                    else "" end) | tostring | .[0:160]),
         interrupt: (.is_interrupt == true),
         err:     ((.error
                    // .tool_error

package/templates/.claude/hooks/scripts/git-delegation-guard.sh

@@ -14,8 +14,18 @@ command -v jq >/dev/null 2>&1 || exit 0
 
 input=$(cat)
 
-agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type // ""')
-prompt=$(printf '%s\n' "$input" | jq -r '.tool_input.prompt // ""')
+# Guard: non-object stdin (non-JSON / JSON array / empty) — swallow and exit 0
+# instead of reflecting garbage back on stdout. The sibling hooks (audit-log.sh,
+# model-escalation-advisor.sh, task-outcome-recorder.sh) all carry this guard;
+# this one did not, so a non-object payload was echoed through verbatim. (#1656 F)
+printf '%s' "$input" | jq -e 'type=="object"' >/dev/null 2>&1 || exit 0
+
+# `?` suppresses jq's "Cannot index <type> with string" when tool_input arrives as a
+# scalar/array instead of an object (measured #1656 A: the bare form leaked a jq error to
+# stderr on every non-object tool_input). 2>/dev/null + `|| echo ""` keep the hook silent
+# and advisory-only even if jq itself fails for an unrelated reason.
+agent_type=$(printf '%s\n' "$input" | jq -r '.tool_input.subagent_type? // ""' 2>/dev/null || echo "")
+prompt=$(printf '%s\n' "$input" | jq -r '.tool_input.prompt? // ""' 2>/dev/null || echo "")
 
 # R010 violation tracking file (PPID-scoped for session persistence)
 VIOLATION_FILE="/tmp/.claude-r010-violations-${PPID}"

package/templates/.claude/hooks/scripts/model-escalation-advisor.sh

@@ -34,13 +34,22 @@ CONSECUTIVE_THRESHOLD=3
 COOLDOWN=5
 
 # Count failures for this agent type
+#
+# `grep -c` COUNT HYGIENE (#1656 E): a no-match `grep -c` prints `0` on stdout AND
+# exits 1, so the old `$(grep -c ... || echo "0")` appended a SECOND zero and the
+# variable became the two-line string "0\n0". Every later `[ "$count" -ge N ]` then
+# failed with "integer expression expected" on stderr — noise indistinguishable
+# from a real hook fault, on the exact path (zero failures) that is the common case.
+# `|| true` keeps grep's own `0` and `${x:-0}` covers an unreadable file.
 agent_failures=0
 if [ -n "$agent_type" ] && [ "$agent_type" != "unknown" ]; then
-  agent_failures=$(grep -c "\"agent_type\":\"${agent_type}\".*\"outcome\":\"failure\"" "$OUTCOME_FILE" 2>/dev/null || echo "0")
+  agent_failures=$(grep -c "\"agent_type\":\"${agent_type}\".*\"outcome\":\"failure\"" "$OUTCOME_FILE" 2>/dev/null || true)
+  agent_failures=${agent_failures:-0}
 fi
 
 # Count consecutive failures (tail entries)
-consecutive_failures=$(tail -${CONSECUTIVE_THRESHOLD} "$OUTCOME_FILE" 2>/dev/null | grep -c '"outcome":"failure"' 2>/dev/null || echo "0")
+consecutive_failures=$(tail -${CONSECUTIVE_THRESHOLD} "$OUTCOME_FILE" 2>/dev/null | grep -c '"outcome":"failure"' 2>/dev/null || true)
+consecutive_failures=${consecutive_failures:-0}
 
 # Escalation path
 # NOTE: Agent tool `model` param is an enum of exactly 4 values: sonnet | opus | haiku | fable.
@@ -90,7 +99,9 @@ fi
 
 # De-escalation check
 if [ "$current_model" != "haiku" ] && [ "$current_model" != "inherit" ] && [ "$current_model" != "" ]; then
-  recent_successes=$(tail -${COOLDOWN} "$OUTCOME_FILE" 2>/dev/null | grep -c '"outcome":"success"' 2>/dev/null || echo "0")
+  # Same `grep -c` hygiene as above (#1656 E).
+  recent_successes=$(tail -${COOLDOWN} "$OUTCOME_FILE" 2>/dev/null | grep -c '"outcome":"success"' 2>/dev/null || true)
+  recent_successes=${recent_successes:-0}
 
   if [ "$recent_successes" -ge "$COOLDOWN" ]; then
     lower_model=""