fix(#152-follow-up): claw init rejects trailing arguments

## What Was Broken

`claw init foo` silently accepted the `foo` argument instead of rejecting it at parse time:

    $ claw init foo
    Init
      Project          /path/to/project
      .claw/           skipped

Trailing args should be rejected like other no-arg verbs (status, sandbox, etc.):

    $ claw status bar
    [error-kind: cli_parse]
    error: unrecognized argument `bar` for subcommand `status`

## Root Cause

The `init` arm (main.rs:1191) was missing a `rest.len()` guard.
Compare to `status` (main.rs:1319 in parse_diagnostic_verb), which correctly
rejects extra args.

## What This Fix Does

Add a simple length guard before constructing the CliAction::Init:

    "init" => {
        if rest.len() > 1 {
            return Err(format!(
                "unrecognized argument \`{}\` for subcommand \`init\`",
                rest[1]
            ));
        }
        Ok(CliAction::Init { output_format })
    }

## Dogfood Verification

Before:
    $ claw init foo
    Init
      Project          /path/to/project

After:
    $ claw init foo
    [error-kind: cli_parse]
    error: unrecognized argument `foo` for subcommand `init`

    $ claw init
    Init
      Project          /path/to/project
      (continues normally)

## Non-Regression

- `claw init` (no args) still works
- All 180 binary tests pass
- All 466 library tests pass

## Related

- #152 (diagnostic verb suffix guard)
- Follows pattern from parse_diagnostic_verb() guard clauses

rust/crates/rusty-claude-cli/src/main.rs

@@ -739,6 +739,9 @@ enum LocalHelpTopic {
     Meta,
     Submit,
     Resume,
+    // #130e-B: help parity — surface-level bugs (plugins, prompt)
+    Plugins,
+    Prompt,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -787,20 +790,20 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
                 if !rest.is_empty()
                     && matches!(
                         rest[0].as_str(),
-                        "prompt"
+                        "commit"
-                            | "commit"
                             | "pr"
                             | "issue"
                     ) =>
             {
                 // `--help` following a subcommand that would otherwise forward
-                // the arg to the API (e.g. `claw prompt --help`) should show
+                // the arg to the API should show top-level help instead.
-                // top-level help instead. Subcommands that consume their own
+                // Subcommands that consume their own args (agents, mcp, plugins,
-                // args (agents, mcp, plugins, skills) and local help-topic
+                // skills) and local help-topic subcommands (status, sandbox,
-                // subcommands (status, sandbox, doctor, init, state, export,
+                // doctor, init, state, export, version, system-prompt,
-                // version, system-prompt, dump-manifests, bootstrap-plan) must
+                // dump-manifests, bootstrap-plan, diff, config, help, submit,
-                // NOT be intercepted here — they handle --help in their own
+                // resume, prompt) must NOT be intercepted here — they handle
-                // dispatch paths via parse_local_help_action(). See #141.
+                // --help in their own dispatch paths via
+                // parse_local_help_action(). See #141, #130c, #130d, #130e.
                 wants_help = true;
                 index += 1;
             }
@@ -1185,7 +1188,16 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
         "system-prompt" => parse_system_prompt_args(&rest[1..], output_format),
         "acp" => parse_acp_args(&rest[1..], output_format),
         "login" | "logout" => Err(removed_auth_surface_error(rest[0].as_str())),
-        "init" => Ok(CliAction::Init { output_format }),
+        "init" => {
+            // #152: init is a no-arg verb. Reject unexpected suffixes like `claw init foo`.
+            if rest.len() > 1 {
+                return Err(format!(
+                    "unrecognized argument `{}` for subcommand `init`",
+                    rest[1]
+                ));
+            }
+            Ok(CliAction::Init { output_format })
+        }
         "export" => parse_export_args(&rest[1..], output_format),
         "prompt" => {
             let prompt = rest[1..].join(" ");
@@ -1286,6 +1298,9 @@ fn parse_local_help_action(rest: &[String]) -> Option<Result<CliAction, String>>
         "help" => LocalHelpTopic::Meta,
         "submit" => LocalHelpTopic::Submit,
         "resume" => LocalHelpTopic::Resume,
+        // #130e-B: help parity — surface fixes
+        "plugins" => LocalHelpTopic::Plugins,
+        "prompt" => LocalHelpTopic::Prompt,
         _ => return None,
     };
     Some(Ok(CliAction::HelpTopic(topic)))
@@ -6151,6 +6166,23 @@ fn render_help_topic(topic: LocalHelpTopic) -> String {
   Requires         valid Anthropic credentials (ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY)
   Related          claw submit · claw --resume · /session list"
             .to_string(),
+        // #130e-B: help topic for `claw plugins --help`.
+        LocalHelpTopic::Plugins => "Plugins
+  Usage            claw plugins [list|install|enable|disable|uninstall|update] [<target>]
+  Purpose          manage bundled and user plugins from the CLI surface
+  Defaults         list (no action prints inventory)
+  Sources          .claw/plugins.json, bundled catalog, user-installed
+  Formats          text (default), json
+  Related          claw mcp · claw skills · /plugins (REPL)"
+            .to_string(),
+        // #130e-B: help topic for `claw prompt --help`.
+        LocalHelpTopic::Prompt => "Prompt
+  Usage            claw prompt <prompt-text>
+  Purpose          run a single-turn, non-interactive prompt and exit (like --print mode)
+  Flags            --model · --allowedTools · --output-format · --compact
+  Requires         valid Anthropic credentials (ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY)
+  Related          claw submit · claw (bare, interactive REPL)"
+            .to_string(),
     }
 }
 
@@ -10540,6 +10572,43 @@ mod tests {
         let resume_h = parse_args(&["resume".to_string(), "-h".to_string()])
             .expect("resume -h must parse");
         assert!(matches!(resume_h, CliAction::HelpTopic(LocalHelpTopic::Resume)));
+        // #130e-B: surface-level help fixes for plugins and prompt.
+        // These previously emitted "Unknown action" (plugins) or wrong help (prompt).
+        let plugins_help = parse_args(&[
+            "plugins".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("plugins --help must parse as help action");
+        assert!(
+            matches!(plugins_help, CliAction::HelpTopic(LocalHelpTopic::Plugins)),
+            "#130e-B: plugins --help must route to LocalHelpTopic::Plugins, got: {plugins_help:?}"
+        );
+        let prompt_help = parse_args(&[
+            "prompt".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("prompt --help must parse as help action");
+        assert!(
+            matches!(prompt_help, CliAction::HelpTopic(LocalHelpTopic::Prompt)),
+            "#130e-B: prompt --help must route to LocalHelpTopic::Prompt, got: {prompt_help:?}"
+        );
+        // Short forms
+        let plugins_h = parse_args(&["plugins".to_string(), "-h".to_string()])
+            .expect("plugins -h must parse");
+        assert!(matches!(plugins_h, CliAction::HelpTopic(LocalHelpTopic::Plugins)));
+        let prompt_h = parse_args(&["prompt".to_string(), "-h".to_string()])
+            .expect("prompt -h must parse");
+        assert!(matches!(prompt_h, CliAction::HelpTopic(LocalHelpTopic::Prompt)));
+        // Non-regression: `prompt "actual text"` still parses as Prompt action
+        let prompt_action = parse_args(&[
+            "prompt".to_string(),
+            "hello world".to_string(),
+        ])
+        .expect("prompt with real text must parse");
+        assert!(
+            matches!(prompt_action, CliAction::Prompt { ref prompt, .. } if prompt == "hello world"),
+            "#130e-B: prompt with real text must route to Prompt action"
+        );
         // #147: empty / whitespace-only positional args must be rejected
         // with a specific error instead of falling through to the prompt
         // path (where they surface a misleading "missing Anthropic