The mode on hooks.json was 000. grok plugin validate still printed hooks at the end of the component line and exited 0. The line above that suffix was Plugin manifest is valid. The file was not opened. A later install of a different copy, twelve bytes and not JSON, also exited 0 and left those twelve bytes in the installed plugin.
That is what Grok 1.0.67 did on 18 November 2026. grok --version printed grok 1.0.67 (2fe064390d07). The host was Linux x86_64. No login was run. No model call was made. No TUI session was started. Each home under test was a new directory passed as HOME. The operator Grok home was not one of those directories, and its timestamp did not move during the run.
The suffix is the filename
grok plugin validate --help says the command validates a plugin manifest. The path defaults to the current directory. The Plugins page this binary wrote on first launch, under the disposable home, tells you to validate a plugin before publishing. The same page says a plugin folder may hold hooks/hooks.json, and that plugin.json is optional. It does not say the validator parses hooks.json. The help text does not say it opens that file. The component line is the sentence a publisher will treat as the check.
Four directories make the line’s meaning visible. Each had a plugin.json with name, version, and description. None of those fields named a hook.
The unreadable file was mode 000. The owner of the file was the user running the command, so the mode blocked that user as well as everyone else. Validate printed:
Plugin manifest is valid.
name: unreadable
version: 0.0.1
description: none
components: 0 skill dir(s), 0 command dir(s), 0 agent dir(s), hooks
The exit code was 0. The process could not have read the hook file. The suffix was still there. After that call the mode was put back to 644 so the fixture could be cleaned up later. The pass had already been recorded.
An empty hooks/ directory, with no hooks.json inside it, produced the same success text and did not print hooks. A directory that held only plugin.json also omitted the suffix. The word is not “this plugin has a hooks directory.” It is “a file named hooks.json is sitting under hooks/.” Presence is the whole test.
A truncated file is present. Its twelve bytes were { "hooks": and a newline. Validate printed hooks and exited 0. Replacing those bytes with {"hooks":"nope"} did not change the result. That value is a string, not an object. The line does not say so. Both files are enough for the suffix. Neither file is a hook document.
The same command on a plugin.json that is not JSON does fail. The file ended after { "name": "broken", and the process exited 1. The text was:
Error: Failed to load manifest: failed to parse <plugin>/plugin.json: EOF while parsing a value at line 2 column 0
The path in the real line was the directory passed to validate. The failure after that path is the manifest parser. It is not a hook parser. A wrapper that only runs validate, and only fails the job when the exit code is not zero, will reject a broken plugin.json and accept a broken hooks.json beside a parseable manifest.
That split is the opposite of what the publishing sentence suggests. The page says to validate before you publish. The help says the object of the command is the manifest. The success text then adds a component inventory. A reader who stops at hooks has treated a filename check as a parse. The inventory is useful as a count of directories and as a flag that hooks/hooks.json exists. It is not useful as a statement that the hook file is JSON, that it was readable, or that a session would run the command inside it.
Install copies the bytes validate did not read
The twelve-byte file was installed with grok plugin install <plugin> --trust. The exit code was 0. The text began Installed 1 plugin(s) from and ended with the name probe-skill. grok plugin details probe-skill then printed the same component line, including hooks, and a path under the disposable home. The copied hooks.json was twelve bytes. Those bytes matched the source. Install did not repair the JSON, and it did not refuse it.
Without --trust, install of a local directory does stop. On a separate plugin whose hook file was readable JSON, the command exited 1 and printed that installation needs explicit trust, then the retry line that adds --trust. That refusal is the trust gate. It is not a parse of hooks.json. The message is asking for a flag. It is not asking you to open the file. Adding the flag is what the message says to do. It is not a substitute for the read validate skipped.
grok inspect after the broken install listed the plugin as user-scoped and enabled, with 1 skills, hooks. The Hooks section was one row: file, and plugin: probe-skill. The JSON form of the same command named that file. hookType was file. event was (plugin). matcher was null. provides.hooks on the plugin object was true.
A second home, whose hooks.json was 86 bytes of valid JSON with a SessionStart command hook, produced the same inspect row. event was (plugin) there too. hookType was file there too. The human Hooks section was again one file row. The row shape does not tell you whether the file parses. A valid hook and a truncated hook are the same inventory entry on this binary. The check that separates them is reading the file, or parsing it, before you enable the plugin.
The log written beside that install did not record a JSON parse error for the hook file. The lines it did write were about a missing auth.json in the disposable home. Absence of a parse error in that log is not evidence that the hook was accepted as a command. It is evidence that inspect’s inventory does not depend on a successful parse. Do not wait for an error line that this command does not emit.
The copied skill file is a separate count, and it has the same shape of mistake. SKILL.md contained the eleven characters not a skill and a newline. There was no front matter. Validate still printed 1 skill dir(s). After install, grok inspect --json listed a skill named probe-skill, with userInvocable true and description set to not a skill. The skills page shipped with this binary says an omitted description falls back to the first paragraph of the body, and an omitted name falls back to the directory name. That fallback explains the inspect fields. It does not explain a validator line that counts the directory as a skill component without saying the file had no front matter. A slash command whose text is the body of a non-skill file is what install leaves behind. Validate’s skill count does not warn you. If the directory name is one you would not want as a slash command, the count is the wrong place to look for that warning.
A missing manifest is a different success
The Plugins page says plugin.json is optional and that Grok discovers components from the standard directories when it is absent. Validate agrees, and then stops.
A directory with no plugin.json, a hooks/hooks.json that was not JSON, and a SKILL.md with no front matter, produced this text and exited 0:
No plugin.json found. Grok discovers skills, agents, and hooks automatically from standard directories. A manifest is only needed for custom paths or metadata.
The line does not name hooks.json. It does not name SKILL.md. It does not say the hook file failed to parse. An empty directory, with no components at all, prints the same sentence and also exits 0. The message is the missing-manifest path. It is not a discovery report. A publisher who follows the page and omits the manifest gets a pass that did not open the files the page says the plugin contains.
The help text and the page can both be true at once. The command validates a manifest when one is present. When one is absent it reports that a manifest is optional. Neither path is a parse of hooks.json. The component suffix, when it appears, is the filename check above. Reading “validate a plugin before publishing” as “the hook file was accepted” is the step the output does not support.
That matters because a hook is not a comment. The hooks page shipped with this binary says a PreToolUse hook can deny a command before it runs, and a Stop hook can keep the agent from finishing a turn. Those are the files you would want a publish check to open. The validator’s hooks suffix does not open them. A file that cannot be read still earns the suffix. A file that is not JSON still earns it, and install will copy it if you pass --trust. The trust flag is a decision that the source may run. It is not a decision that the source parsed.
Verify the hook file
Point HOME at a directory you can throw away. Do not point it at the home you use for real sessions. Put the plugin in its own directory. If a previous command exported GROK_HOME, unset it. This run’s first install wrote into a home named by that variable, not into the HOME of the later command. A wrapper that sets one and inherits the other will update the wrong tree and then describe that tree as the install.
export HOME=<disposable-home>
unset GROK_HOME
grok plugin validate <plugin>
Then open hooks/hooks.json. On 1.0.67, a zero exit and a line that ends in hooks are compatible with mode 000, with a truncated file, and with a JSON value that is not an object. The word is present because the filename is present.
Parse the file before you install. The twelve-byte copy this run installed fails that parse. Python 3.13 reported:
JSONDecodeError: Expecting value: line 2 column 1 (char 12)
That error is the check validate did not run. A readable file with a string where an object belongs fails the same way, and validate still printed hooks for that file. After grok plugin install <plugin> --trust, compare the installed hooks.json with the source. On this build the copy was the source, including the truncated source. grok plugin details will repeat the suffix. grok inspect will list a file row for a valid hook and for this truncated hook. Neither command is the parse.
If the plugin has no plugin.json, do not treat the missing-manifest sentence as a component report. It is printed for an empty directory and for a directory whose hook file does not parse. Open the standard paths yourself: skills/, commands/, agents/, hooks/hooks.json, .mcp.json, and .lsp.json. The page lists those paths. Validate does not read them when the manifest is absent, and it does not parse hooks.json when the manifest is present.
The public changelog fetched the same night lists Grok Build 1.0.89 on 17 November 2026. This host printed 1.0.67. The 1.0.88 notes say an empty or whitespace-only hook file now loads without error. That sentence is about loading a hook. It is not a description of plugin validate, and it was not the binary under test. Do not treat a later load-time note as a statement that 1.0.67 opened the file. The mode 000 result is the statement. The file was not opened, the command exited 0, and the component line still said hooks.
Sources
- Grok 1.0.67, version line
grok 1.0.67 (2fe064390d07), Linux x86_64, 18 November 2026. Validate, install, details, and inspect ran withHOMEset to disposable directories. No login and no model call. - Plugins and skills user-guide pages written by that binary on first launch in a disposable home, 18 November 2026. The Plugins page says to validate before publishing, says
plugin.jsonis optional, and listshooks/hooks.jsonas a plugin file. The skills page describes the name and description fallbacks used by inspect.grok plugin validate --helpsays the command validates a plugin manifest. - Grok Build changelog, fetched 18 November 2026. Version 1.0.89 is dated 17 November 2026. Version 1.0.88 says an empty or whitespace-only hook file now loads without error. This host was not upgraded to either release.