failproofai 0.0.1-beta.5 → 0.0.1-beta.7

package/.next/standalone/src/hooks/hooks-config.ts

@@ -1,5 +1,5 @@
 /**
- * Read/write the hooks configuration file at ~/.failproofai/hooks-config.json.
+ * Read/write the hooks configuration file at ~/.failproofai/policies-config.json.
  */
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { resolve, dirname } from "node:path";
@@ -20,21 +20,21 @@ function readConfigAt(path: string): Partial<HooksConfig> {
 
 /**
  * Read and merge hooks config from three scopes in priority order:
- *   1. {cwd}/.failproofai/hooks-config.json        (project)
- *   2. {cwd}/.failproofai/hooks-config.local.json  (local)
- *   3. ~/.failproofai/hooks-config.json             (global)
+ *   1. {cwd}/.failproofai/policies-config.json        (project)
+ *   2. {cwd}/.failproofai/policies-config.local.json  (local)
+ *   3. ~/.failproofai/policies-config.json             (global)
  *
  * Merge rules:
  *   enabledPolicies: union + dedup across all three
  *   policyParams:    per-policy key, first scope that defines it wins entirely
- *   customHooksPath: first scope that defines it wins
+ *   customPoliciesPath: first scope that defines it wins
  *   llm:            first scope that defines it wins
  */
 export function readMergedHooksConfig(cwd?: string): HooksConfig {
   const base = cwd ? resolve(cwd) : process.cwd();
-  const projectPath = resolve(base, ".failproofai", "hooks-config.json");
-  const localPath = resolve(base, ".failproofai", "hooks-config.local.json");
-  const globalPath = resolve(homedir(), ".failproofai", "hooks-config.json");
+  const projectPath = resolve(base, ".failproofai", "policies-config.json");
+  const localPath = resolve(base, ".failproofai", "policies-config.local.json");
+  const globalPath = resolve(homedir(), ".failproofai", "policies-config.json");
 
   const project = readConfigAt(projectPath);
   const local = readConfigAt(localPath);
@@ -58,9 +58,9 @@ export function readMergedHooksConfig(cwd?: string): HooksConfig {
     }
   }
 
-  // customHooksPath: first scope wins
-  const customHooksPath =
-    project.customHooksPath ?? local.customHooksPath ?? global_.customHooksPath;
+  // customPoliciesPath: first scope wins
+  const customPoliciesPath =
+    project.customPoliciesPath ?? local.customPoliciesPath ?? global_.customPoliciesPath;
 
   // llm: first scope wins
   const llm = project.llm ?? local.llm ?? global_.llm;
@@ -68,13 +68,13 @@ export function readMergedHooksConfig(cwd?: string): HooksConfig {
   return {
     enabledPolicies: [...enabledSet],
     ...(Object.keys(mergedParams).length > 0 ? { policyParams: mergedParams } : {}),
-    ...(customHooksPath !== undefined ? { customHooksPath } : {}),
+    ...(customPoliciesPath !== undefined ? { customPoliciesPath } : {}),
     ...(llm !== undefined ? { llm } : {}),
   };
 }
 
 function getConfigPath(): string {
-  return resolve(homedir(), ".failproofai", "hooks-config.json");
+  return resolve(homedir(), ".failproofai", "policies-config.json");
 }
 
 export function readHooksConfig(): HooksConfig {

package/.next/standalone/src/hooks/install-prompt.ts

@@ -263,11 +263,11 @@ export async function promptPolicySelection(
     );
     lines.push("");
     lines.push(
-      "  \x1B[2mTip: --list-policies for a flat list \u00b7 --install-policies <name\u2026> to skip prompt\x1B[0m",
+      "  \x1B[2mTip: `policies` for a flat list \u00b7 `policies --install <name\u2026>` to skip prompt\x1B[0m",
     );
     if (!includeBeta) {
       lines.push(
-        "  \x1B[2mTip: --install-policies all --beta to include beta policies\x1B[0m",
+        "  \x1B[2mTip: `policies --install --beta` to include beta policies\x1B[0m",
       );
     }
 

package/.next/standalone/src/hooks/llm-client.ts

@@ -2,7 +2,7 @@
  * Shared OpenAI-compatible chat completions client.
  *
  * Uses raw `fetch` — no SDK dependency. Any policy can import this
- * to make LLM calls using the shared configuration from hooks-config.json
+ * to make LLM calls using the shared configuration from policies-config.json
  * or environment variables.
  */
 import { readLlmConfig } from "./hooks-config";
@@ -35,7 +35,7 @@ export async function chatCompletion(
   const config = readLlmConfig();
   if (!config) {
     throw new Error(
-      "No LLM API key configured. Set FAILPROOFAI_LLM_API_KEY or configure llm.apiKey in hooks-config.json",
+      "No LLM API key configured. Set FAILPROOFAI_LLM_API_KEY or configure llm.apiKey in policies-config.json",
     );
   }
 

package/.next/standalone/src/hooks/manager.ts

@@ -182,7 +182,7 @@ export async function installHooks(
   cwd?: string,
   includeBeta = false,
   source?: string,
-  customHooksPath?: string,
+  customPoliciesPath?: string,
   removeCustomHooks = false,
 ): Promise<void> {
   const binaryPath = resolveFailproofaiBinary();
@@ -212,23 +212,23 @@ export async function installHooks(
     selectedPolicies = await promptPolicySelection(preSelected, { includeBeta });
   }
 
-  // Preserve existing config fields (policyParams, customHooksPath, llm) when updating
+  // Preserve existing config fields (policyParams, customPoliciesPath, llm) when updating
   const configToWrite = { ...previousConfig, enabledPolicies: selectedPolicies };
   if (removeCustomHooks) {
-    delete configToWrite.customHooksPath;
-  } else if (customHooksPath) {
-    configToWrite.customHooksPath = resolve(customHooksPath);
+    delete configToWrite.customPoliciesPath;
+  } else if (customPoliciesPath) {
+    configToWrite.customPoliciesPath = resolve(customPoliciesPath);
     // Validate the file before committing it to config
     let validatedHooks: Awaited<ReturnType<typeof loadCustomHooks>> = [];
     try {
-      validatedHooks = await loadCustomHooks(configToWrite.customHooksPath, { strict: true });
+      validatedHooks = await loadCustomHooks(configToWrite.customPoliciesPath, { strict: true });
     } catch (err) {
       console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
       process.exit(1);
     }
     if (validatedHooks.length === 0) {
       console.error(
-        `Error: no hooks registered in ${customHooksPath}. ` +
+        `Error: no hooks registered in ${customPoliciesPath}. ` +
           `Make sure your file calls customPolicies.add(...) at least once.`,
       );
       process.exit(1);
@@ -241,8 +241,8 @@ export async function installHooks(
   console.log(`\nEnabled ${selectedPolicies.length} policy(ies): ${selectedPolicies.join(", ")}`);
   if (removeCustomHooks) {
     console.log("Custom hooks path cleared.");
-  } else if (configToWrite.customHooksPath) {
-    console.log(`Custom hooks path: ${configToWrite.customHooksPath}`);
+  } else if (configToWrite.customPoliciesPath) {
+    console.log(`Custom hooks path: ${configToWrite.customPoliciesPath}`);
   }
 
   const settingsPath = getSettingsPath(scope, cwd);
@@ -306,7 +306,7 @@ export async function installHooks(
       arch: arch(),
       os_release: release(),
       hostname_hash: hashToId(hostname()),
-      has_custom_hooks_path: !!(configToWrite.customHooksPath),
+      has_custom_hooks_path: !!(configToWrite.customPoliciesPath),
       has_policy_params: !!(configToWrite.policyParams && Object.keys(configToWrite.policyParams).length > 0),
       param_policy_names: configToWrite.policyParams ? Object.keys(configToWrite.policyParams) : [],
     });
@@ -326,8 +326,8 @@ export async function installHooks(
     console.log();
     console.log(`\x1B[33mWarning: Failproof AI hooks are also installed at ${scopeList}.\x1B[0m`);
     console.log(`Having hooks in multiple scopes may cause duplicate policy evaluation.`);
-    console.log(`Use \`failproofai --remove-policies --scope ${duplicates[0]}\` to remove the other installation,`);
-    console.log(`or \`failproofai --list-policies\` to see all scopes.`);
+    console.log(`Use \`failproofai policies --uninstall --scope ${duplicates[0]}\` to remove the other installation,`);
+    console.log(`or \`failproofai policies\` to see all scopes.`);
   }
 }
 
@@ -340,7 +340,15 @@ export async function installHooks(
  * @param scope — settings scope to remove from (default: "user"), or "all" to remove from all scopes
  * @param opts.betaOnly — set to true when removing only beta policies (adds beta_only flag to telemetry)
  */
-export async function removeHooks(policyNames?: string[], scope: HookScope | "all" = "user", cwd?: string, opts?: { betaOnly?: boolean; source?: string }): Promise<void> {
+export async function removeHooks(policyNames?: string[], scope: HookScope | "all" = "user", cwd?: string, opts?: { betaOnly?: boolean; source?: string; removeCustomHooks?: boolean }): Promise<void> {
+  // Clear custom hooks path if requested
+  if (opts?.removeCustomHooks) {
+    const config = readHooksConfig();
+    delete config.customPoliciesPath;
+    writeHooksConfig(config);
+    console.log("Custom hooks path cleared.");
+  }
+
   // Remove specific policies from config (keep hooks installed)
   if (policyNames && policyNames.length > 0 && !(policyNames.length === 1 && policyNames[0] === "all")) {
     validatePolicyNames(policyNames);
@@ -452,7 +460,7 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
   // Clear policy config when removing from all scopes, or when no hooks remain in any scope
   if (scope === "all" || !HOOK_SCOPES.some((s) => hooksInstalledInSettings(s, cwd))) {
     const existingForClear = readHooksConfig();
-    const { customHooksPath: _drop, policyParams: _dropParams, ...restClear } = existingForClear;
+    const { customPoliciesPath: _drop, policyParams: _dropParams, ...restClear } = existingForClear;
     writeHooksConfig({ ...restClear, enabledPolicies: [] });
   }
 }
@@ -467,7 +475,7 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
  * Also shows:
  *   - Configured policyParams values beneath each policy
  *   - Warnings for unknown policyParams keys
- *   - Custom Hooks section if customHooksPath is set
+ *   - Custom Hooks section if customPoliciesPath is set
  */
 export async function listHooks(cwd?: string): Promise<void> {
   const config = readMergedHooksConfig(cwd);
@@ -520,11 +528,11 @@ export async function listHooks(cwd?: string): Promise<void> {
     printBetaSection(printSimpleRow);
 
     if (config.enabledPolicies.length > 0) {
-      console.log("\n  Policies not installed. Run `failproofai --install-policies` to activate.");
+      console.log("\n  Policies not installed. Run `failproofai policies --install` to activate.");
     } else {
-      console.log("\n  Run `failproofai --install-policies` to get started.");
+      console.log("\n  Run `failproofai policies --install` to get started.");
     }
-    console.log("  Config: ~/.failproofai/hooks-config.json\n");
+    console.log("  Config: ~/.failproofai/policies-config.json\n");
   } else if (installedScopes.length === 1) {
     // State B: Single scope — table with header row
     const scope = installedScopes[0];
@@ -536,7 +544,7 @@ export async function listHooks(cwd?: string): Promise<void> {
     for (const policy of regularPolicies) printSimpleRow(policy);
     printBetaSection(printSimpleRow);
 
-    console.log("\n  Config: ~/.failproofai/hooks-config.json\n");
+    console.log("\n  Config: ~/.failproofai/policies-config.json\n");
   } else {
     // State C: Multiple scopes — column table
     const COL = 9;
@@ -580,13 +588,13 @@ export async function listHooks(cwd?: string): Promise<void> {
       for (const policy of betaPolicies) printMultiScopeRow(policy);
     }
 
-    console.log("\n  Config: ~/.failproofai/hooks-config.json");
+    console.log("\n  Config: ~/.failproofai/policies-config.json");
 
     // Multi-scope warning
     const scopeNames = installedScopes.join(", ");
     console.log();
     console.log(`\x1B[33m\u26A0 Hooks in multiple scopes (${scopeNames}).\x1B[0m`);
-    console.log("  Consider keeping one. Remove with: failproofai --remove-policies --scope <scope>\n");
+    console.log("  Consider keeping one. Remove with: failproofai policies --uninstall --scope <scope>\n");
   }
 
   // Warn about unknown policyParams keys
@@ -599,12 +607,12 @@ export async function listHooks(cwd?: string): Promise<void> {
   }
 
   // Custom Policies section
-  if (config.customHooksPath) {
-    console.log(`\n  \u2500\u2500 Custom Policies (${config.customHooksPath}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
-    if (!existsSync(config.customHooksPath)) {
-      console.log(`  \x1B[31m\u2717 File not found: ${config.customHooksPath}\x1B[0m`);
+  if (config.customPoliciesPath) {
+    console.log(`\n  \u2500\u2500 Custom Policies (${config.customPoliciesPath}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    if (!existsSync(config.customPoliciesPath)) {
+      console.log(`  \x1B[31m\u2717 File not found: ${config.customPoliciesPath}\x1B[0m`);
     } else {
-      const hooks = await loadCustomHooks(config.customHooksPath);
+      const hooks = await loadCustomHooks(config.customPoliciesPath);
       if (hooks.length === 0) {
         console.log(`  \x1B[31m\u2717 ERR  failed to load (check ~/.failproofai/logs/hooks.log)\x1B[0m`);
       } else {

package/.next/standalone/src/hooks/policy-types.ts

@@ -73,5 +73,5 @@ export interface HooksConfig {
   enabledPolicies: string[];
   llm?: LlmConfig;
   policyParams?: Record<string, Record<string, unknown>>;
-  customHooksPath?: string;
+  customPoliciesPath?: string;
 }

package/README.md

@@ -89,7 +89,7 @@ failproofai --remove-policies --scope project
 
 ## Configuration
 
-Policy configuration lives in `~/.failproofai/hooks-config.json` (global) or `.failproofai/hooks-config.json` in your project (per-project).
+Policy configuration lives in `~/.failproofai/policies-config.json` (global) or `.failproofai/policies-config.json` in your project (per-project).
 
 ```json
 {
@@ -182,7 +182,7 @@ customPolicies.add({
 Install with:
 
 ```bash
-failproofai --install-policies --custom-hooks ./my-policies.js
+failproofai --install-policies --custom ./my-policies.js
 ```
 
 ### Decision helpers

package/bin/failproofai.mjs

@@ -5,9 +5,8 @@
  * Handles:
  *   --hook <event>        Hook event from Claude Code (minimal startup latency)
  *   --version / -v        Print version and exit
- *   --install-policies    Install hooks + enable policies in Claude Code settings
- *   --remove-policies     Remove hooks or disable policies from Claude Code settings
- *   --list-policies       List available policies and their status
+ *   --help / -h           Show usage and exit
+ *   policies              Manage policies (list / install / uninstall)
  *   (default)             Launch production dashboard
  */
 import { realpathSync } from "node:fs";
@@ -27,6 +26,52 @@ if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
 
 const args = process.argv.slice(2);
 
+// --help / -h  (only when not inside a subcommand that handles its own --help)
+const SUBCOMMANDS = ["policies"];
+if ((args.includes("--help") || args.includes("-h")) && !SUBCOMMANDS.includes(args[0])) {
+  console.log(`
+failproofai v${version}
+
+USAGE
+  failproofai [command] [options]
+
+COMMANDS
+  (no args)                      Launch the policy dashboard
+
+  policies                       List all available policies and their status
+  policies --install, -i         Enable policies in Claude Code settings
+    [names...]                     Specific policy names to enable
+    --scope user|project|local     Config scope to write to (default: user)
+    --beta                         Include beta policies
+    --custom, -c <path>            Path to a JS file of custom policies
+
+  policies --uninstall, -u       Disable policies or remove hooks
+    [names...]                     Specific policy names to disable
+    --scope user|project|local|all Config scope to remove from (default: user)
+    --beta                         Remove only beta policies
+    --custom, -c                   Clear the customPoliciesPath from config
+
+  policies --help, -h            Show this help for the policies command
+
+  --version, -v                  Print version and exit
+  --help, -h                     Show this help message
+
+EXAMPLES
+  failproofai policies
+  failproofai policies --install
+  failproofai policies --install block-sudo sanitize-api-keys --scope project
+  failproofai policies --install --custom ./my-policies.js
+  failproofai policies -i -c ./my-policies.js
+  failproofai policies --uninstall block-sudo
+  failproofai policies --uninstall --custom
+
+LINKS
+  ⭐ Star us:      https://github.com/exospherehost/failproofai
+  📖 Docs:         https://befailproof.ai
+`.trimStart());
+  process.exit(0);
+}
+
 // --version / -v
 if (args.includes("--version") || args.includes("-v")) {
   console.log(version);
@@ -41,70 +86,121 @@ if (hookIdx >= 0 && args[hookIdx + 1]) {
   process.exit(exitCode);
 }
 
-// --install-policies [policyNames...] [--scope user|project|local] [--beta] [--custom-hooks <path>] [--remove-custom-hooks]
-if (args.includes("--install-policies")) {
-  const { installHooks } = await import("../src/hooks/manager");
-
-  const scopeIdx = args.indexOf("--scope");
-  const scope = scopeIdx >= 0 ? args[scopeIdx + 1] : "user";
-
-  const customHooksIdx = args.indexOf("--custom-hooks");
-  const customHooksPath = customHooksIdx >= 0 ? args[customHooksIdx + 1] : undefined;
-
-  const includeBeta = args.includes("--beta");
-  const removeCustomHooks = args.includes("--remove-custom-hooks");
-
-  // Collect positional policy names (args after --install-policies that don't start with --)
-  const installIdx = args.indexOf("--install-policies");
-  const policyNames = args
-    .slice(installIdx + 1)
-    .filter((a) => !a.startsWith("--") && a !== scope && a !== customHooksPath);
-
-  await installHooks(
-    policyNames.length > 0 ? policyNames : undefined,
-    scope,
-    undefined,
-    includeBeta,
-    undefined,
-    customHooksPath,
-    removeCustomHooks,
-  );
-  process.exit(0);
-}
+// policies [--install|-i|--uninstall|-u|--help|-h] [names...] [--scope] [--beta] [--custom|-c <path>]
+if (args[0] === "policies") {
+  const subArgs = args.slice(1);
+
+  const isInstall   = subArgs.includes("--install")   || subArgs.includes("-i");
+  const isUninstall = subArgs.includes("--uninstall")  || subArgs.includes("-u");
+  const isHelp      = subArgs.includes("--help")       || subArgs.includes("-h");
+
+  if (isHelp) {
+    console.log(`
+failproofai policies — manage Failproof AI policies
+
+USAGE
+  failproofai policies                       List all policies and their status
+  failproofai policies --install, -i         Enable policies
+  failproofai policies --uninstall, -u       Disable policies or remove hooks
+
+OPTIONS (install)
+  [names...]                     Specific policy names to enable (omit for interactive)
+  --scope user|project|local     Config scope to write to (default: user)
+  --beta                         Include beta policies
+  --custom, -c <path>            Path to a JS file of custom policies
+                                 (skips interactive prompt; validates file first)
+
+OPTIONS (uninstall)
+  [names...]                     Specific policy names to disable (omit to remove hooks)
+  --scope user|project|local|all Config scope to remove from (default: user)
+  --beta                         Remove only beta policies
+  --custom, -c                   Clear the customPoliciesPath from config
+
+EXAMPLES
+  failproofai policies
+  failproofai policies --install
+  failproofai policies --install block-sudo sanitize-api-keys
+  failproofai policies --install --custom ./my-policies.js
+  failproofai policies -i -c ./my-policies.js
+  failproofai policies --uninstall block-sudo
+  failproofai policies -u
+  failproofai policies --uninstall --custom
+`.trimStart());
+    process.exit(0);
+  }
 
-// --remove-policies [policyNames...] [--scope user|project|local|all] [--beta-only]
-if (args.includes("--remove-policies")) {
-  const { removeHooks } = await import("../src/hooks/manager");
+  if (isInstall) {
+    const { installHooks } = await import("../src/hooks/manager");
 
-  const scopeIdx = args.indexOf("--scope");
-  const scope = scopeIdx >= 0 ? args[scopeIdx + 1] : "user";
+    const scopeIdx = subArgs.indexOf("--scope");
+    const scope = scopeIdx >= 0 ? subArgs[scopeIdx + 1] : "user";
 
-  const betaOnly = args.includes("--beta-only");
+    const customIdx = subArgs.includes("--custom") ? subArgs.indexOf("--custom")
+                    : subArgs.includes("-c")        ? subArgs.indexOf("-c")
+                    : -1;
+    const customPoliciesPath = customIdx >= 0 ? subArgs[customIdx + 1] : undefined;
 
-  const removeIdx = args.indexOf("--remove-policies");
-  const policyNames = args
-    .slice(removeIdx + 1)
-    .filter((a) => !a.startsWith("--") && a !== scope);
+    const includeBeta = subArgs.includes("--beta");
 
-  await removeHooks(
-    policyNames.length > 0 ? policyNames : undefined,
-    scope,
-    undefined,
-    { betaOnly },
-  );
-  process.exit(0);
-}
+    // Collect positional policy names — args that don't start with - and aren't
+    // values consumed by --scope or --custom/-c.
+    const consumed = new Set([scope, customPoliciesPath].filter(Boolean));
+    const flags = new Set(["--install", "-i", "--scope", "--beta", "--custom", "-c"]);
+    const explicitPolicyNames = subArgs.filter(
+      (a) => !a.startsWith("-") && !flags.has(a) && !consumed.has(a)
+    );
 
-// --list-policies
-if (args.includes("--list-policies")) {
+    // When --custom/-c is present but no explicit policy names, pass [] so
+    // installHooks uses the existing enabled policies and skips the interactive
+    // prompt — validation of the custom file happens inside installHooks.
+    const policyNames =
+      explicitPolicyNames.length > 0 ? explicitPolicyNames
+      : customPoliciesPath !== undefined ? []
+      : undefined;
+
+    await installHooks(
+      policyNames,
+      scope,
+      undefined,
+      includeBeta,
+      undefined,
+      customPoliciesPath,
+    );
+    process.exit(0);
+  }
+
+  if (isUninstall) {
+    const { removeHooks } = await import("../src/hooks/manager");
+
+    const scopeIdx = subArgs.indexOf("--scope");
+    const scope = scopeIdx >= 0 ? subArgs[scopeIdx + 1] : "user";
+
+    const betaOnly = subArgs.includes("--beta");
+    const removeCustomHooks = subArgs.includes("--custom") || subArgs.includes("-c");
+
+    const consumed = new Set([scope].filter(Boolean));
+    const flags = new Set(["--uninstall", "-u", "--scope", "--beta", "--custom", "-c"]);
+    const policyNames = subArgs.filter(
+      (a) => !a.startsWith("-") && !flags.has(a) && !consumed.has(a)
+    );
+
+    await removeHooks(
+      policyNames.length > 0 ? policyNames : undefined,
+      scope,
+      undefined,
+      { betaOnly, removeCustomHooks },
+    );
+    process.exit(0);
+  }
+
+  // Default: list policies
   const { listHooks } = await import("../src/hooks/manager");
   await listHooks();
   process.exit(0);
 }
 
 // Unknown flag guard — must appear after all known-flag branches
-const knownFlags = ["--version", "-v", "--hook", "--install-policies",
-                    "--remove-policies", "--list-policies"];
+const knownFlags = ["--version", "-v", "--help", "-h", "--hook"];
 const unknownFlag = args.find(a => a.startsWith("-") && !knownFlags.includes(a));
 
 if (unknownFlag) {
@@ -121,8 +217,7 @@ if (unknownFlag) {
     return dp[m][n];
   }
 
-  const primary = ["--version", "--hook", "--install-policies",
-                   "--remove-policies", "--list-policies"];
+  const primary = ["--version", "--help", "--hook", "policies"];
   const closest = primary.reduce((best, flag) => {
     const dist = levenshtein(unknownFlag, flag);
     return dist < best.dist ? { flag, dist } : best;
@@ -130,6 +225,16 @@ if (unknownFlag) {
 
   console.error(`Unknown flag: ${unknownFlag}`);
   console.error(`Did you mean: ${closest.flag}?`);
+  console.error(`Run \`failproofai --help\` for usage details.`);
+  process.exit(1);
+}
+
+// Unknown subcommand guard (non-flag args that aren't "policies")
+const unknownSubcommand = args.find(a => !a.startsWith("-") && a !== "policies");
+if (unknownSubcommand) {
+  console.error(`Unknown command: ${unknownSubcommand}`);
+  console.error(`Did you mean: failproofai policies?`);
+  console.error(`Run \`failproofai --help\` for usage details.`);
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "0.0.1-beta.5",
+  "version": "0.0.1-beta.7",
   "description": "Open-source hooks, policies, and project visualization for Claude Code & Agents SDK",
   "bin": {
     "failproofai": "./bin/failproofai.mjs"

package/scripts/launch.ts

@@ -20,6 +20,8 @@ export function launch(mode: "dev" | "start"): void {
 /_/    \\__,_/_/_/ .___/_/   \\____/\\____/_/    /_/  |_/___/
                /_/   v${version}
 `);
+  console.log(`  ⭐ Star us:      https://github.com/exospherehost/failproofai`);
+  console.log(`  📖 Docs:         https://befailproof.ai\n`);
 
   let claudeProjectsPath = parsedPath;
 

package/scripts/postinstall.mjs

@@ -30,7 +30,7 @@ function hashToId(raw) {
  * @returns {{ configured: boolean, registered: boolean, policyCount: number }}
  */
 function checkHooks() {
-  const hooksConfigPath = resolve(homedir(), ".failproofai", "hooks-config.json");
+  const hooksConfigPath = resolve(homedir(), ".failproofai", "policies-config.json");
   if (!existsSync(hooksConfigPath)) {
     return { configured: false, registered: false, policyCount: 0 };
   }
@@ -87,7 +87,7 @@ function printHooksWarning() {
   console.log(
     `\n[failproofai] Warning: hooks config exists with enabled policies, but hooks are not registered in Claude Code settings.\n` +
     `  To re-register hooks, run:\n` +
-    `    failproofai --remove-policies && failproofai --install-policies\n`
+    `    failproofai policies --uninstall && failproofai policies --install\n`
   );
 }
 

package/src/hooks/custom-hooks-loader.ts

@@ -16,18 +16,18 @@ import type { CustomHook } from "./policy-types";
 const LOADING_KEY = "__FAILPROOFAI_LOADING_HOOKS__";
 
 export async function loadCustomHooks(
-  customHooksPath: string | undefined,
+  customPoliciesPath: string | undefined,
   opts?: { strict?: boolean },
 ): Promise<CustomHook[]> {
-  if (!customHooksPath) return [];
+  if (!customPoliciesPath) return [];
 
-  const absPath = isAbsolute(customHooksPath)
-    ? customHooksPath
-    : resolve(process.cwd(), customHooksPath);
+  const absPath = isAbsolute(customPoliciesPath)
+    ? customPoliciesPath
+    : resolve(process.cwd(), customPoliciesPath);
 
   if (!existsSync(absPath)) {
     if (opts?.strict) throw new Error(`Custom hooks file not found: ${absPath}`);
-    hookLogWarn(`customHooksPath not found: ${absPath}`);
+    hookLogWarn(`customPoliciesPath not found: ${absPath}`);
     return [];
   }
 

package/src/hooks/handler.ts

@@ -2,7 +2,7 @@
  * Hook event handler — invoked when Claude Code triggers a hook.
  *
  * Reads the JSON payload from stdin, loads enabled policies from
- * ~/.failproofai/hooks-config.json, evaluates matching policies, persists
+ * ~/.failproofai/policies-config.json, evaluates matching policies, persists
  * activity to disk, and returns the appropriate exit code + stdout response.
  */
 import type { HookEventType, SessionMetadata } from "./types";
@@ -71,7 +71,7 @@ export async function handleHookEvent(eventType: string): Promise<number> {
   registerBuiltinPolicies(config.enabledPolicies);
 
   // Load and register custom hooks (layer 2, after builtins)
-  const customHooksList = await loadCustomHooks(config.customHooksPath);
+  const customHooksList = await loadCustomHooks(config.customPoliciesPath);
   for (const hook of customHooksList) {
     const hookName = hook.name;
     const fn: PolicyFunction = async (ctx): Promise<PolicyResult> => {