failproofai 0.0.2-beta.5 → 0.0.2-beta.7

package/.next/standalone/dist/cli.mjs

@@ -149,11 +149,19 @@ function readMergedHooksConfig(cwd) {
     ...llm !== undefined ? { llm } : {}
   };
 }
-function getConfigPath() {
-  return resolve(homedir2(), ".failproofai", "policies-config.json");
+function getConfigPathForScope(scope, cwd) {
+  const base = cwd ? resolve(cwd) : process.cwd();
+  switch (scope) {
+    case "user":
+      return resolve(homedir2(), ".failproofai", "policies-config.json");
+    case "project":
+      return resolve(base, ".failproofai", "policies-config.json");
+    case "local":
+      return resolve(base, ".failproofai", "policies-config.local.json");
+  }
 }
-function readHooksConfig() {
-  const configPath = getConfigPath();
+function readScopedHooksConfig(scope, cwd) {
+  const configPath = getConfigPathForScope(scope, cwd);
   if (!existsSync2(configPath)) {
     return { enabledPolicies: [] };
   }
@@ -165,8 +173,8 @@ function readHooksConfig() {
     return { enabledPolicies: [] };
   }
 }
-function writeHooksConfig(config) {
-  const configPath = getConfigPath();
+function writeScopedHooksConfig(config, scope, cwd) {
+  const configPath = getConfigPathForScope(scope, cwd);
   const dir = dirname(configPath);
   if (!existsSync2(dir)) {
     mkdirSync2(dir, { recursive: true });
@@ -282,6 +290,37 @@ function getCurrentBranch(cwd) {
     return null;
   }
 }
+function getHeadSha(cwd) {
+  try {
+    const sha = execSync("git rev-parse HEAD", {
+      cwd,
+      encoding: "utf8",
+      timeout: 3000
+    }).trim();
+    return sha || null;
+  } catch {
+    return null;
+  }
+}
+function getThirdPartyCheckRuns(cwd, sha) {
+  try {
+    const json = execFileSync("gh", [
+      "api",
+      `repos/{owner}/{repo}/commits/${sha}/check-runs`,
+      "--jq",
+      '.check_runs | map(select(.app.slug != "github-actions")) | map({name: .name, status: .status, conclusion: (.conclusion // "")})'
+    ], {
+      cwd,
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    if (!json || json === "[]")
+      return [];
+    return JSON.parse(json);
+  } catch {
+    return [];
+  }
+}
 function matchesAllowedPattern(cmd, pattern) {
   const cmdTokens = parseArgvTokens(cmd);
   const patTokens = parseArgvTokens(pattern);
@@ -814,6 +853,20 @@ function requirePushBeforeStop(ctx) {
     const branch = getCurrentBranch(cwd);
     if (!branch || branch === "HEAD")
       return allow("Detached HEAD, skipping push check.");
+    const baseBranch = ctx.params?.baseBranch ?? "main";
+    if (branch === baseBranch) {
+      return allow(`On base branch "${baseBranch}", skipping push check.`);
+    }
+    try {
+      const ahead = execFileSync("git", ["log", `${remote}/${baseBranch}..HEAD`, "--oneline"], { cwd, encoding: "utf8", timeout: 5000 }).trim();
+      if (!ahead) {
+        return allow(`No commits ahead of ${remote}/${baseBranch}, skipping push check.`);
+      }
+      const diff = execFileSync("git", ["diff", "--stat", `${remote}/${baseBranch}`, "HEAD"], { cwd, encoding: "utf8", timeout: 5000 }).trim();
+      if (!diff) {
+        return allow(`No file changes compared to ${remote}/${baseBranch}, skipping push check.`);
+      }
+    } catch {}
     let hasTracking = false;
     try {
       execFileSync("git", ["rev-parse", "--verify", `${remote}/${branch}`], {
@@ -900,22 +953,27 @@ function requireCiGreenBeforeStop(ctx) {
     const branch = getCurrentBranch(cwd);
     if (!branch || branch === "HEAD")
       return allow("Detached HEAD, skipping CI check.");
-    const runsJson = execFileSync("gh", ["run", "list", "--branch", branch, "--limit", "5", "--json", "status,conclusion,name"], {
-      cwd,
-      encoding: "utf8",
-      timeout: 15000
-    }).trim();
-    if (!runsJson || runsJson === "[]")
-      return allow(`No CI runs found for branch "${branch}".`);
-    const runs = JSON.parse(runsJson);
-    if (runs.length === 0)
+    let workflowRuns = [];
+    try {
+      const runsJson = execFileSync("gh", ["run", "list", "--branch", branch, "--limit", "5", "--json", "status,conclusion,name"], { cwd, encoding: "utf8", timeout: 15000 }).trim();
+      if (runsJson && runsJson !== "[]") {
+        workflowRuns = JSON.parse(runsJson);
+      }
+    } catch {}
+    let thirdPartyChecks = [];
+    const sha = getHeadSha(cwd);
+    if (sha) {
+      thirdPartyChecks = getThirdPartyCheckRuns(cwd, sha);
+    }
+    const allChecks = [...workflowRuns, ...thirdPartyChecks];
+    if (allChecks.length === 0)
       return allow(`No CI runs found for branch "${branch}".`);
-    const failing = runs.filter((r) => r.status === "completed" && r.conclusion !== "success" && r.conclusion !== "skipped");
+    const failing = allChecks.filter((r) => r.status === "completed" && r.conclusion !== "success" && r.conclusion !== "skipped");
     if (failing.length > 0) {
       const names = failing.map((r) => `"${r.name}"`).join(", ");
       return deny(`CI checks are failing on branch "${branch}": ${names}. Fix the failing checks before stopping.`);
     }
-    const pending = runs.filter((r) => r.status === "in_progress" || r.status === "queued" || r.status === "waiting");
+    const pending = allChecks.filter((r) => r.status === "in_progress" || r.status === "queued" || r.status === "waiting");
     if (pending.length > 0) {
       const names = pending.map((r) => `"${r.name}"`).join(", ");
       return deny(`CI checks are still running on branch "${branch}": ${names}. Wait for all checks to complete and verify they pass.`);
@@ -1283,6 +1341,11 @@ var init_builtin_policies = __esm(() => {
           type: "string",
           description: "Remote name to push to (default: origin)",
           default: "origin"
+        },
+        baseBranch: {
+          type: "string",
+          description: "Base branch to compare against (default: main)",
+          default: "main"
         }
       }
     },
@@ -1315,6 +1378,15 @@ var init_builtin_policies = __esm(() => {
 });
 
 // src/hooks/policy-evaluator.ts
+function appendHint(baseReason, hint) {
+  const base = baseReason.trim();
+  const normalizedHint = typeof hint === "string" ? hint.trim() : "";
+  if (!normalizedHint)
+    return base;
+  if (!base)
+    return normalizedHint;
+  return `${base}. ${normalizedHint}`;
+}
 async function evaluatePolicies(eventType, payload, session, config) {
   const toolName = payload.tool_name;
   const toolInput = payload.tool_input;
@@ -1354,7 +1426,7 @@ async function evaluatePolicies(eventType, payload, session, config) {
       continue;
     }
     if (result.decision === "deny") {
-      const reason = result.reason ?? `Blocked by policy: ${policy.name}`;
+      const reason = appendHint(result.reason ?? `Blocked by policy: ${policy.name}`, config?.policyParams?.[policy.name]?.hint);
       hookLogInfo(`deny by "${policy.name}": ${reason}`);
       const displayTool = ctx.toolName ?? "unknown tool";
       if (eventType === "PreToolUse") {
@@ -1401,7 +1473,7 @@ async function evaluatePolicies(eventType, payload, session, config) {
     }
     if (result.decision === "instruct" && !instructPolicyName) {
       instructPolicyName = policy.name;
-      instructReason = result.reason ?? `Instruction from policy: ${policy.name}`;
+      instructReason = appendHint(result.reason ?? `Instruction from policy: ${policy.name}`, config?.policyParams?.[policy.name]?.hint);
       hookLogInfo(`instruct by "${policy.name}": ${instructReason}`);
     }
     if (result.decision === "allow" && result.reason) {
@@ -1514,10 +1586,9 @@ async function createEsmShim(distIndex, distUrl) {
   const shimPath = distIndex + ".__failproofai_esm_shim__.mjs";
   const shimCode = [
     `import _cjs from '${distUrl}';`,
-    `export const createApp = _cjs.createApp;`,
-    `export const getQueueCondition = _cjs.getQueueCondition;`,
-    `export const clearQueueCondition = _cjs.clearQueueCondition;`,
     `export const customPolicies = _cjs.customPolicies;`,
+    `export const getCustomHooks = _cjs.getCustomHooks;`,
+    `export const clearCustomHooks = _cjs.clearCustomHooks;`,
     `export const allow = _cjs.allow;`,
     `export const deny = _cjs.deny;`,
     `export const instruct = _cjs.instruct;`,
@@ -1597,20 +1668,21 @@ var init_loader_utils = __esm(() => {
 });
 
 // src/hooks/custom-hooks-loader.ts
-import { resolve as resolve4, isAbsolute } from "node:path";
-import { existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve4, isAbsolute, basename } from "node:path";
+import { existsSync as existsSync3, readdirSync } from "node:fs";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-async function loadCustomHooks(customPoliciesPath, opts) {
-  if (!customPoliciesPath)
+import { homedir as homedir4 } from "node:os";
+function discoverPolicyFiles(dir) {
+  if (!existsSync3(dir))
     return [];
-  const absPath = isAbsolute(customPoliciesPath) ? customPoliciesPath : resolve4(process.cwd(), customPoliciesPath);
-  if (!existsSync3(absPath)) {
-    if (opts?.strict)
-      throw new Error(`Custom hooks file not found: ${absPath}`);
-    hookLogWarn(`customPoliciesPath not found: ${absPath}`);
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && CONVENTION_FILE_RE.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => resolve4(dir, e.name));
+  } catch {
     return [];
   }
-  clearCustomHooks();
+}
+async function loadSingleFile(absPath, opts) {
   const g = globalThis;
   g[LOADING_KEY] = true;
   let tmpFiles = [];
@@ -1626,18 +1698,87 @@ async function loadCustomHooks(customPoliciesPath, opts) {
     if (opts?.strict)
       throw new Error(`Failed to load custom hooks from ${absPath}: ${msg}`);
     hookLogError(`failed to load custom hooks from ${absPath}: ${msg}`);
-    return [];
   } finally {
     g[LOADING_KEY] = false;
     await cleanupTmpFiles(tmpFiles);
   }
+}
+async function loadCustomHooks(customPoliciesPath, opts) {
+  if (!customPoliciesPath)
+    return [];
+  const absPath = isAbsolute(customPoliciesPath) ? customPoliciesPath : resolve4(opts?.sessionCwd ?? process.cwd(), customPoliciesPath);
+  if (!existsSync3(absPath)) {
+    if (opts?.strict)
+      throw new Error(`Custom hooks file not found: ${absPath}`);
+    hookLogWarn(`customPoliciesPath not found: ${absPath}`);
+    return [];
+  }
+  clearCustomHooks();
+  await loadSingleFile(absPath, opts);
   return getCustomHooks();
 }
-var LOADING_KEY = "__FAILPROOFAI_LOADING_HOOKS__";
+async function loadAllCustomHooks(customPoliciesPath, opts) {
+  clearCustomHooks();
+  const conventionSources = [];
+  if (customPoliciesPath) {
+    const absPath = isAbsolute(customPoliciesPath) ? customPoliciesPath : resolve4(opts?.sessionCwd ?? process.cwd(), customPoliciesPath);
+    if (existsSync3(absPath)) {
+      await loadSingleFile(absPath);
+    } else {
+      hookLogWarn(`customPoliciesPath not found: ${absPath}`);
+    }
+  }
+  const hooksBeforeConvention = getCustomHooks().length;
+  const projectDir = resolve4(opts?.sessionCwd ?? process.cwd(), ".failproofai", "policies");
+  const projectFiles = discoverPolicyFiles(projectDir);
+  for (const file of projectFiles) {
+    const hooksBefore = getCustomHooks().length;
+    await loadSingleFile(file);
+    const newHooks = getCustomHooks().slice(hooksBefore);
+    if (newHooks.length > 0) {
+      conventionSources.push({
+        scope: "project",
+        file: basename(file),
+        hookNames: newHooks.map((h) => h.name)
+      });
+    }
+  }
+  const userDir = resolve4(homedir4(), ".failproofai", "policies");
+  const userFiles = discoverPolicyFiles(userDir);
+  for (const file of userFiles) {
+    const hooksBefore = getCustomHooks().length;
+    await loadSingleFile(file);
+    const newHooks = getCustomHooks().slice(hooksBefore);
+    if (newHooks.length > 0) {
+      conventionSources.push({
+        scope: "user",
+        file: basename(file),
+        hookNames: newHooks.map((h) => h.name)
+      });
+    }
+  }
+  const allHooks = getCustomHooks();
+  const conventionCount = allHooks.length - hooksBeforeConvention;
+  if (projectFiles.length > 0 || userFiles.length > 0) {
+    hookLogInfo(`convention policies: ${projectFiles.length} project file(s), ${userFiles.length} user file(s), ${conventionCount} hook(s)`);
+  }
+  const conventionHookRefs = new Set;
+  for (const hook of allHooks.slice(hooksBeforeConvention)) {
+    conventionHookRefs.add(hook);
+  }
+  for (const hook of allHooks) {
+    if (conventionHookRefs.has(hook)) {
+      hook.__conventionSource = true;
+    }
+  }
+  return { hooks: allHooks, conventionSources };
+}
+var LOADING_KEY = "__FAILPROOFAI_LOADING_HOOKS__", CONVENTION_FILE_RE;
 var init_custom_hooks_loader = __esm(() => {
   init_hook_logger();
   init_custom_hooks_registry();
   init_loader_utils();
+  CONVENTION_FILE_RE = /policies\.(js|mjs|ts)$/;
 });
 
 // src/hooks/hook-activity-store.ts
@@ -1646,14 +1787,14 @@ import {
   writeFileSync as writeFileSync2,
   appendFileSync as appendFileSync2,
   renameSync as renameSync2,
-  readdirSync,
+  readdirSync as readdirSync2,
   mkdirSync as mkdirSync3,
   existsSync as existsSync4,
   statSync as statSync2,
   unlinkSync
 } from "node:fs";
 import { join as join3 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 function ensureDir() {
   if (!existsSync4(storeDir)) {
     mkdirSync3(storeDir, { recursive: true });
@@ -1758,12 +1899,12 @@ function updateStats(entry) {
 }
 var PAGE_SIZE = 25, DEFAULT_STORE_DIR, CURRENT_FILE = "current.jsonl", COUNT_FILE = "current.count", STATS_FILE = "stats.json", LOCK_FILE = "current.lock", LOCK_STALE_MS = 2000, storeDir, rotateSeq = 0;
 var init_hook_activity_store = __esm(() => {
-  DEFAULT_STORE_DIR = join3(homedir4(), ".failproofai", "cache", "hook-activity");
+  DEFAULT_STORE_DIR = join3(homedir5(), ".failproofai", "cache", "hook-activity");
   storeDir = DEFAULT_STORE_DIR;
 });
 
 // package.json
-var version2 = "0.0.2-beta.5";
+var version2 = "0.0.2-beta.7";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -1925,9 +2066,13 @@ async function handleHookEvent(eventType) {
   const config = readMergedHooksConfig(session.cwd);
   clearPolicies();
   registerBuiltinPolicies(config.enabledPolicies);
-  const customHooksList = await loadCustomHooks(config.customPoliciesPath);
+  const loadResult = await loadAllCustomHooks(config.customPoliciesPath, { sessionCwd: session.cwd });
+  const customHooksList = loadResult.hooks;
+  const conventionHookNames = new Set(loadResult.conventionSources.flatMap((s) => s.hookNames));
   for (const hook of customHooksList) {
     const hookName = hook.name;
+    const isConvention = hook.__conventionSource === true;
+    const prefix = isConvention ? "convention" : "custom";
     const fn = async (ctx) => {
       try {
         const result2 = await Promise.race([
@@ -1938,16 +2083,17 @@ async function handleHookEvent(eventType) {
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         const isTimeout = msg === "timeout";
-        hookLogWarn(`custom hook "${hookName}" failed: ${msg}`);
+        hookLogWarn(`${prefix} hook "${hookName}" failed: ${msg}`);
         trackHookEvent(getInstanceId(), "custom_hook_error", {
           hook_name: hookName,
           error_type: isTimeout ? "timeout" : "exception",
-          event_type: eventType
+          event_type: eventType,
+          is_convention_policy: isConvention
         });
         return { decision: "allow" };
       }
     };
-    registerPolicy(`custom/${hookName}`, hook.description ?? "", fn, hook.match ?? {}, -1);
+    registerPolicy(`${prefix}/${hookName}`, hook.description ?? "", fn, hook.match ?? {}, -1);
   }
   if (customHooksList.length > 0) {
     trackHookEvent(getInstanceId(), "custom_hooks_loaded", {
@@ -1956,7 +2102,16 @@ async function handleHookEvent(eventType) {
       event_types_covered: [...new Set(customHooksList.flatMap((h) => h.match?.events ?? []))]
     });
   }
-  hookLogInfo(`event=${eventType} policies=${config.enabledPolicies.length} custom=${customHooksList.length}`);
+  if (loadResult.conventionSources.length > 0) {
+    trackHookEvent(getInstanceId(), "convention_policies_loaded", {
+      event_type: eventType,
+      project_file_count: loadResult.conventionSources.filter((s) => s.scope === "project").length,
+      user_file_count: loadResult.conventionSources.filter((s) => s.scope === "user").length,
+      convention_hook_count: conventionHookNames.size,
+      convention_hook_names: [...conventionHookNames]
+    });
+  }
+  hookLogInfo(`event=${eventType} policies=${config.enabledPolicies.length} custom=${customHooksList.length} convention=${conventionHookNames.size}`);
   const result = await evaluatePolicies(eventType, parsed, session, config);
   const durationMs = Math.round(performance.now() - startTime);
   hookLogInfo(`result=${result.decision} policy=${result.policyName ?? "none"} duration=${durationMs}ms`);
@@ -1988,7 +2143,8 @@ async function handleHookEvent(eventType) {
   if (result.decision === "deny" || result.decision === "instruct") {
     try {
       const isCustomHook = result.policyName?.startsWith("custom/") ?? false;
-      const hasCustomParams = !isCustomHook && !!(result.policyName && config.policyParams?.[result.policyName]);
+      const isConventionPolicy = result.policyName?.startsWith("convention/") ?? false;
+      const hasCustomParams = !isCustomHook && !isConventionPolicy && !!(result.policyName && config.policyParams?.[result.policyName]);
       const paramKeysOverridden = hasCustomParams ? Object.keys(config.policyParams[result.policyName]) : [];
       const distinctId = getInstanceId();
       await trackHookEvent(distinctId, "hook_policy_triggered", {
@@ -1997,6 +2153,7 @@ async function handleHookEvent(eventType) {
         policy_name: result.policyName,
         decision: result.decision,
         is_custom_hook: isCustomHook,
+        is_convention_policy: isConventionPolicy,
         has_custom_params: hasCustomParams,
         param_keys_overridden: paramKeysOverridden
       });
@@ -2329,13 +2486,13 @@ __export(exports_manager, {
 });
 import { execSync as execSync3 } from "node:child_process";
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "node:fs";
-import { resolve as resolve5, dirname as dirname3 } from "node:path";
-import { homedir as homedir5, platform, arch, release, hostname } from "node:os";
+import { resolve as resolve5, dirname as dirname3, basename as basename2 } from "node:path";
+import { homedir as homedir6, platform, arch, release, hostname } from "node:os";
 function getSettingsPath(scope, cwd) {
   const base = cwd ? resolve5(cwd) : process.cwd();
   switch (scope) {
     case "user":
-      return resolve5(homedir5(), ".claude", "settings.json");
+      return resolve5(homedir6(), ".claude", "settings.json");
     case "project":
       return resolve5(base, ".claude", "settings.json");
     case "local":
@@ -2462,7 +2619,7 @@ async function installHooks(policyNames, scope = "user", cwd, includeBeta = fals
     }
   }
   const binaryPath = resolveFailproofaiBinary();
-  const previousConfig = readHooksConfig();
+  const previousConfig = readScopedHooksConfig(scope, cwd);
   const previousEnabled = new Set(previousConfig.enabledPolicies);
   let selectedPolicies;
   if (policyNames !== undefined) {
@@ -2496,7 +2653,7 @@ async function installHooks(policyNames, scope = "user", cwd, includeBeta = fals
     console.log(`
 Validated ${validatedHooks.length} custom hook(s): ${validatedHooks.map((h) => h.name).join(", ")}`);
   }
-  writeHooksConfig(configToWrite);
+  writeScopedHooksConfig(configToWrite, scope, cwd);
   console.log(`
 Enabled ${selectedPolicies.length} policy(ies): ${selectedPolicies.join(", ")}`);
   if (removeCustomHooks) {
@@ -2573,15 +2730,16 @@ Enabled ${selectedPolicies.length} policy(ies): ${selectedPolicies.join(", ")}`)
   }
 }
 async function removeHooks(policyNames, scope = "user", cwd, opts) {
+  const configScope = scope === "all" ? "user" : scope;
   if (opts?.removeCustomHooks) {
-    const config = readHooksConfig();
+    const config = readScopedHooksConfig(configScope, cwd);
     delete config.customPoliciesPath;
-    writeHooksConfig(config);
+    writeScopedHooksConfig(config, configScope, cwd);
     console.log("Custom hooks path cleared.");
   }
   if (policyNames && policyNames.length > 0 && !(policyNames.length === 1 && policyNames[0] === "all")) {
     validatePolicyNames(policyNames);
-    const config = readHooksConfig();
+    const config = readScopedHooksConfig(configScope, cwd);
     const removeSet = new Set(policyNames);
     const remaining = config.enabledPolicies.filter((p) => !removeSet.has(p));
     const notEnabled = policyNames.filter((p) => !config.enabledPolicies.includes(p));
@@ -2595,7 +2753,7 @@ async function removeHooks(policyNames, scope = "user", cwd, opts) {
       enabledPolicies: remaining,
       ...filteredParams && Object.keys(filteredParams).length > 0 ? { policyParams: filteredParams } : {}
     };
-    writeHooksConfig(updatedConfig);
+    writeScopedHooksConfig(updatedConfig, configScope, cwd);
     try {
       const distinctId = getInstanceId();
       const actuallyRemoved = policyNames.filter((p) => config.enabledPolicies.includes(p));
@@ -2616,7 +2774,7 @@ async function removeHooks(policyNames, scope = "user", cwd, opts) {
     console.log(`Remaining: ${remaining.length > 0 ? remaining.join(", ") : "(none)"}`);
     return;
   }
-  const configBeforeRemoval = readHooksConfig();
+  const configBeforeRemoval = readScopedHooksConfig(configScope, cwd);
   const scopesToRemove = scope === "all" ? [...HOOK_SCOPES] : [scope];
   let totalRemoved = 0;
   for (const s of scopesToRemove) {
@@ -2663,10 +2821,18 @@ async function removeHooks(policyNames, scope = "user", cwd, opts) {
       hostname_hash: hashToId(hostname())
     });
   } catch {}
-  if (scope === "all" || !HOOK_SCOPES.some((s) => hooksInstalledInSettings(s, cwd))) {
-    const existingForClear = readHooksConfig();
-    const { customPoliciesPath: _drop, policyParams: _dropParams, ...restClear } = existingForClear;
-    writeHooksConfig({ ...restClear, enabledPolicies: [] });
+  if (scope === "all") {
+    for (const s of HOOK_SCOPES) {
+      const existing = readScopedHooksConfig(s, cwd);
+      if (existing.enabledPolicies.length > 0 || existing.customPoliciesPath || existing.policyParams) {
+        const { customPoliciesPath: _drop, policyParams: _dropParams, ...rest } = existing;
+        writeScopedHooksConfig({ ...rest, enabledPolicies: [] }, s, cwd);
+      }
+    }
+  } else if (!HOOK_SCOPES.some((s) => hooksInstalledInSettings(s, cwd))) {
+    const existing = readScopedHooksConfig(configScope, cwd);
+    const { customPoliciesPath: _drop, policyParams: _dropParams, ...rest } = existing;
+    writeScopedHooksConfig({ ...rest, enabledPolicies: [] }, configScope, cwd);
   }
 }
 async function listHooks(cwd) {
@@ -2803,6 +2969,35 @@ Failproof AI Hook Policies
     }
     console.log();
   }
+  const base = cwd ? resolve5(cwd) : process.cwd();
+  const conventionDirs = [
+    { label: "Project", dir: resolve5(base, ".failproofai", "policies") },
+    { label: "User", dir: resolve5(homedir6(), ".failproofai", "policies") }
+  ];
+  for (const { label, dir } of conventionDirs) {
+    const files = discoverPolicyFiles(dir);
+    if (files.length === 0)
+      continue;
+    console.log(`
+  ── Convention Policies — ${label} (${dir}) ──────────`);
+    for (const file of files) {
+      try {
+        const hooks = await loadCustomHooks(file);
+        if (hooks.length === 0) {
+          const filename = basename2(file);
+          console.log(`  \x1B[31m✗\x1B[0m       ${filename.padEnd(nameColWidth)}\x1B[31mfailed to load\x1B[0m`);
+        } else {
+          const filename = basename2(file);
+          const hookSummary = hooks.map((h) => h.name).join(", ");
+          console.log(`  \x1B[32m✓\x1B[0m       ${filename.padEnd(nameColWidth)}${hooks.length} hook(s): ${hookSummary}`);
+        }
+      } catch {
+        const filename = basename2(file);
+        console.log(`  \x1B[31m✗\x1B[0m       ${filename.padEnd(nameColWidth)}\x1B[31merror\x1B[0m`);
+      }
+    }
+    console.log();
+  }
 }
 var VALID_POLICY_NAMES;
 var init_manager = __esm(() => {
@@ -2818,10 +3013,10 @@ var init_manager = __esm(() => {
 });
 
 // lib/paths.ts
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join4 } from "path";
 function getDefaultClaudeProjectsPath() {
-  return join4(homedir6(), ".claude", "projects");
+  return join4(homedir7(), ".claude", "projects");
 }
 var init_paths = () => {};
 
@@ -2990,7 +3185,7 @@ import { realpathSync as realpathSync2 } from "fs";
 import { dirname as dirname5, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // package.json
-var version = "0.0.2-beta.5";
+var version = "0.0.2-beta.7";
 
 // bin/failproofai.mjs
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
@@ -3054,6 +3249,11 @@ COMMANDS
   --version, -v                  Print version and exit
   --help, -h                     Show this help message
 
+CONVENTION POLICIES
+  Drop *policies.{js,mjs,ts} files into .failproofai/policies/ for auto-loading.
+  Works at project level (.failproofai/policies/) and user level (~/.failproofai/policies/).
+  No --custom flag or config changes needed \u2014 just drop files and they're picked up.
+
 EXAMPLES
   failproofai policies
   failproofai policies --install

package/.next/standalone/docs/built-in-policies.mdx

@@ -491,14 +491,14 @@ pull requests. If `gh` is not installed or not authenticated, the policy fails o
 ### `require-ci-green-before-stop`
 
 **Event:** Stop  
-**Default:** Denies stopping when CI checks are failing or still running on the current branch. Treats `skipped` conclusions as success. Returns an informational message when all checks pass.
+**Default:** Denies stopping when CI checks are failing or still running on the current branch. Checks both GitHub Actions workflow runs and third-party bot checks (e.g. CodeRabbit, SonarCloud, Codecov). Treats `skipped` conclusions as success. Returns an informational message when all checks pass.
 
 No parameters.
 
 <Note>
 This policy requires [GitHub CLI](https://cli.github.com/) (`gh`) to be installed and authenticated.
 Run `gh auth login` with a personal access token that has `repo` scope for read access to
-Actions workflow runs. If `gh` is not installed or not authenticated, the policy fails open and reports the reason to Claude.
+Actions workflow runs and the Checks API. If `gh` is not installed or not authenticated, the policy fails open and reports the reason to Claude.
 </Note>
 
 ---

package/.next/standalone/docs/configuration.mdx

@@ -116,6 +116,35 @@ If a policy has parameters but you don't specify them, the policy's built-in def
 
 Unknown keys inside a policy's params block are silently ignored at hook-fire time but flagged as warnings when you run `failproofai policies`.
 
+#### `hint` (cross-cutting)
+
+Type: `string` (optional)
+
+A message appended to the reason when a policy returns `deny` or `instruct`. Use it to give Claude actionable guidance without modifying the policy itself.
+
+Works with any policy type — built-in, custom (`custom/`), or convention (`convention/`).
+
+```json
+{
+  "policyParams": {
+    "block-force-push": {
+      "hint": "Try creating a fresh branch instead."
+    },
+    "block-sudo": {
+      "allowPatterns": ["sudo apt-get"],
+      "hint": "Use apt-get directly without sudo."
+    },
+    "custom/my-policy": {
+      "hint": "Ask the user for approval first."
+    }
+  }
+}
+```
+
+When `block-force-push` denies, Claude sees: *"Force-pushing is blocked. Try creating a fresh branch instead."*
+
+Non-string values and empty strings are silently ignored. If `hint` is not set, behavior is unchanged (backward-compatible).
+
 ### `customPoliciesPath`
 
 Type: `string` (absolute path)
@@ -124,6 +153,23 @@ Path to a JavaScript file containing custom hook policies. This is set automatic
 
 The file is loaded fresh on every hook event - there is no caching. See [Custom Policies](/custom-policies) for authoring details.
 
+### Convention-based policies (v0.0.2-beta.7+)
+
+In addition to the explicit `customPoliciesPath`, failproofai automatically discovers and loads policy files from `.failproofai/policies/` directories:
+
+| Level | Directory | Scope |
+|-------|-----------|-------|
+| Project | `.failproofai/policies/` | Shared with team via version control |
+| User | `~/.failproofai/policies/` | Personal, applies to all projects |
+
+**File matching:** Only files matching `*policies.{js,mjs,ts}` are loaded (e.g. `security-policies.mjs`, `workflow-policies.js`). Other files in the directory are ignored.
+
+**No config needed:** Convention policies require no entries in `policies-config.json`. Just drop files into the directory and they're picked up on the next hook event.
+
+**Union loading:** Both project and user convention directories are scanned. All matching files from both levels are loaded (unlike `customPoliciesPath` which uses first-scope-wins).
+
+See [Custom Policies](/custom-policies) for more details and examples.
+
 ### `llm`
 
 Type: `object` (optional)