fix(#130e-A): route help/submit/resume --help to help topics before credential check

## What Was Broken (ROADMAP #130e, filed cycle #53)

Three subcommands leaked `missing_credentials` errors when called
with `--help`:

    $ claw help --help
    [error-kind: missing_credentials]
    error: missing Anthropic credentials...

    $ claw submit --help
    [error-kind: missing_credentials]
    error: missing Anthropic credentials...

    $ claw resume --help
    [error-kind: missing_credentials]
    error: missing Anthropic credentials...

This is the same dispatch-order bug class as #251 (session verbs).
The parser fell through to the credential check before help-flag
resolution ran. Critical discoverability gap: users couldn't learn
what these commands do without valid credentials.

## Root Cause (Traced)

`parse_local_help_action()` (main.rs:1260) is called early in
`parse_args()` (main.rs:1002), BEFORE credential check. But the
match statement inside only recognized:
status, sandbox, doctor, acp, init, state, export, version,
system-prompt, dump-manifests, bootstrap-plan, diff, config.

`help`, `submit`, `resume` were NOT in the list, so the function
returned `None`, and parsing continued to credential check which
then failed.

## What This Fix Does

Same pattern as #130c (diff) and #130d (config):

1. **LocalHelpTopic enum extended** with Meta, Submit, Resume variants
2. **parse_local_help_action() extended** to map the three new cases
3. **Help topic renderers added** with accurate usage info

Three-line change to parse_local_help_action:

    "help" => LocalHelpTopic::Meta,
    "submit" => LocalHelpTopic::Submit,
    "resume" => LocalHelpTopic::Resume,

Dispatch order (parse_args):
    1. --resume parsing
    2. parse_local_help_action() ← NOW catches help/submit/resume --help
    3. parse_single_word_command_alias()
    4. parse_subcommand() ← Credential check happens here

## Dogfood Verification

Before fix (all three):
    $ claw help --help
    [error-kind: missing_credentials]
    error: missing Anthropic credentials...

After fix:
    $ claw help --help
    Help
      Usage            claw help [--output-format <format>]
      Purpose          show the full CLI help text (all subcommands, flags, environment)
      ...

    $ claw submit --help
    Submit
      Usage            claw submit [--session <id|latest>] <prompt-text>
      Purpose          send a prompt to an existing managed session
      Requires         valid Anthropic credentials (when actually submitting)
      ...

    $ claw resume --help
    Resume
      Usage            claw resume [<session-id|latest>]
      Purpose          restart an interactive REPL attached to a managed session
      ...

## Non-Regression Verification

- `claw help` (no --help) → still shows full CLI help ✅
- `claw submit "text"` (with prompt) → still requires credentials ✅
- `claw resume` (bare) → still emits slash command guidance ✅
- All 180 binary tests pass ✅
- All 466 library tests pass ✅

## Regression Tests Added (6 assertions)

- `help --help` → routes to HelpTopic(Meta)
- `submit --help` → routes to HelpTopic(Submit)
- `resume --help` → routes to HelpTopic(Resume)
- Short forms: `help -h`, `submit -h`, `resume -h` all work

## Pattern Note

This is Category A of #130e (dispatch-order bugs). Same class as #251.
Category B (surface-parity: plugins, prompt) will be handled in a
follow-up commit/branch.

## Help-Parity Sweep Status

After cycle #52 (#130c diff, #130d config), help sweep revealed:

| Command | Before | After This Commit |
|---|---|---|
| help --help | missing_credentials | ✅ Meta help |
| submit --help | missing_credentials | ✅ Submit help |
| resume --help | missing_credentials | ✅ Resume help |
| plugins --help | "Unknown action" | ⏳ #130e-B (next) |
| prompt --help | wrong help | ⏳ #130e-B (next) |

## Related

- Closes #130e Category A (dispatch-order help fixes)
- Same bug class as #251 (session verbs)
- Stacks on #130d (config help) on same worktree branch
- #130e Category B (plugins, prompt) queued for follow-up

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

@@ -257,10 +257,18 @@ Run `claw --help` for usage."
 /// Returns a snake_case token that downstream consumers can switch on instead
 /// of regex-scraping the prose. The classification is best-effort prefix/keyword
 /// matching against the error messages produced throughout the CLI surface.
+/// #130b: Wrap io::Error with operation context so classifier can recognize filesystem failures.
+fn contextualize_io_error(operation: &str, target: &str, error: std::io::Error) -> String {
+    format!("{} failed: {} ({})", operation, target, error)
+}
+
 fn classify_error_kind(message: &str) -> &'static str {
     // Check specific patterns first (more specific before generic)
     if message.contains("missing Anthropic credentials") {
         "missing_credentials"
+    } else if message.contains("export failed:") || message.contains("diff failed:") || message.contains("config failed:") {
+        // #130b: Filesystem operation errors enriched with operation+path context.
+        "filesystem_io_error"
     } else if message.contains("Manifest source files are missing") {
         "missing_manifests"
     } else if message.contains("no worker state file found") {
@@ -723,6 +731,14 @@ enum LocalHelpTopic {
     SystemPrompt,
     DumpManifests,
     BootstrapPlan,
+    // #130c: help parity for `claw diff --help`
+    Diff,
+    // #130d: help parity for `claw config --help`
+    Config,
+    // #130e: help parity — dispatch-order bugs (help, submit, resume)
+    Meta,
+    Submit,
+    Resume,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -1036,6 +1052,10 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
         // which is synthetic friction. Accepts an optional section name
         // (env|hooks|model|plugins) matching the slash command shape.
         "config" => {
+            // #130d: accept --help / -h and route to help topic instead of silently ignoring
+            if rest.len() >= 2 && is_help_flag(&rest[1]) {
+                return Ok(CliAction::HelpTopic(LocalHelpTopic::Config));
+            }
             let tail = &rest[1..];
             let section = tail.first().cloned();
             if tail.len() > 1 {
@@ -1053,6 +1073,12 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
         // #146: `diff` is pure-local (shells out to `git diff --cached` +
         // `git diff`). No session needed to inspect the working tree.
         "diff" => {
+            // #130c: accept --help / -h as first argument and route to help topic,
+            // matching the behavior of status/sandbox/doctor/etc.
+            // Without this guard, `claw diff --help` was rejected as extra arguments.
+            if rest.len() == 2 && is_help_flag(&rest[1]) {
+                return Ok(CliAction::HelpTopic(LocalHelpTopic::Diff));
+            }
             if rest.len() > 1 {
                 return Err(format!(
                     "unexpected extra arguments after `claw diff`: {}",
@@ -1252,6 +1278,14 @@ fn parse_local_help_action(rest: &[String]) -> Option<Result<CliAction, String>>
         "system-prompt" => LocalHelpTopic::SystemPrompt,
         "dump-manifests" => LocalHelpTopic::DumpManifests,
         "bootstrap-plan" => LocalHelpTopic::BootstrapPlan,
+        // #130c: help parity for `claw diff --help`
+        "diff" => LocalHelpTopic::Diff,
+        // #130d: help parity for `claw config --help`
+        "config" => LocalHelpTopic::Config,
+        // #130e: help parity — dispatch-order fixes
+        "help" => LocalHelpTopic::Meta,
+        "submit" => LocalHelpTopic::Submit,
+        "resume" => LocalHelpTopic::Resume,
         _ => return None,
     };
     Some(Ok(CliAction::HelpTopic(topic)))
@@ -6075,6 +6109,48 @@ fn render_help_topic(topic: LocalHelpTopic) -> String {
   Formats          text (default), json
   Related          claw doctor · claw status"
             .to_string(),
+        // #130c: help topic for `claw diff --help`.
+        LocalHelpTopic::Diff => "Diff
+  Usage            claw diff [--output-format <format>]
+  Purpose          show local git staged + unstaged changes for the current workspace
+  Requires         workspace must be inside a git repository
+  Output           unified diff (text) or structured diff object (json)
+  Formats          text (default), json
+  Related          claw status · claw config"
+            .to_string(),
+        // #130d: help topic for `claw config --help`.
+        LocalHelpTopic::Config => "Config
+  Usage            claw config [--cwd <path>] [--output-format <format>]
+  Purpose          merge and display the resolved .claw.json / settings.json configuration
+  Options          --cwd overrides the workspace directory for config lookup
+  Output           loaded files and merged key-value pairs (text) or JSON object (json)
+  Formats          text (default), json
+  Related          claw status · claw doctor · claw init"
+            .to_string(),
+        // #130e: help topic for `claw help --help` (meta-help).
+        LocalHelpTopic::Meta => "Help
+  Usage            claw help [--output-format <format>]
+  Purpose          show the full CLI help text (all subcommands, flags, environment)
+  Aliases          claw --help · claw -h
+  Formats          text (default), json
+  Related          claw <subcommand> --help · claw version"
+            .to_string(),
+        // #130e: help topic for `claw submit --help`.
+        LocalHelpTopic::Submit => "Submit
+  Usage            claw submit [--session <id|latest>] <prompt-text>
+  Purpose          send a prompt to an existing managed session without starting a new one
+  Defaults         --session latest (resumes the most recent managed session)
+  Requires         valid Anthropic credentials (ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY)
+  Related          claw prompt · claw --resume · /session list"
+            .to_string(),
+        // #130e: help topic for `claw resume --help`.
+        LocalHelpTopic::Resume => "Resume
+  Usage            claw resume [<session-id|latest>]
+  Purpose          restart an interactive REPL attached to a managed session
+  Defaults         latest session if no argument provided
+  Requires         valid Anthropic credentials (ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY)
+  Related          claw submit · claw --resume · /session list"
+            .to_string(),
     }
 }
 
@@ -6908,7 +6984,10 @@ fn run_export(
     let markdown = render_session_markdown(&session, &handle.id, &handle.path);
 
     if let Some(path) = output_path {
-        fs::write(path, &markdown)?;
+        // #130b: Wrap io::Error with operation context so classifier recognizes filesystem failures.
+        fs::write(path, &markdown).map_err(|e| -> Box<dyn std::error::Error> {
+            contextualize_io_error("export", &path.display().to_string(), e).into()
+        })?;
         let report = format!(
             "Export\n  Result           wrote markdown transcript\n  File             {}\n  Session          {}\n  Messages         {}",
             path.display(),
@@ -10302,6 +10381,165 @@ mod tests {
             extra_err.contains("unexpected extra arguments"),
             "extra-args error should be specific, got: {extra_err}"
         );
+        // #130b: classify_error_kind must recognize filesystem operation errors.
+        // Messages produced by contextualize_io_error() must route to
+        // "filesystem_io_error" kind, not default "unknown". This closes the
+        // context-loss chain (run_export -> fs::write -> ? -> to_string ->
+        // classify miss -> unknown) that #130b identified.
+        let export_err_msg = "export failed: /tmp/bad/path (No such file or directory (os error 2))";
+        assert_eq!(
+            classify_error_kind(export_err_msg),
+            "filesystem_io_error",
+            "#130b: export fs::write errors must classify as filesystem_io_error, not unknown"
+        );
+        let diff_err_msg = "diff failed: /tmp/nowhere (Permission denied (os error 13))";
+        assert_eq!(
+            classify_error_kind(diff_err_msg),
+            "filesystem_io_error",
+            "#130b: diff fs errors must classify as filesystem_io_error"
+        );
+        let config_err_msg = "config failed: /tmp/x (Is a directory (os error 21))";
+        assert_eq!(
+            classify_error_kind(config_err_msg),
+            "filesystem_io_error",
+            "#130b: config fs errors must classify as filesystem_io_error"
+        );
+        // #130b: contextualize_io_error must produce messages that the classifier recognizes.
+        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "No such file or directory");
+        let enriched = super::contextualize_io_error("export", "/tmp/bad/path", io_err);
+        assert!(
+            enriched.contains("export failed:"),
+            "#130b: contextualize_io_error must include operation name, got: {enriched}"
+        );
+        assert!(
+            enriched.contains("/tmp/bad/path"),
+            "#130b: contextualize_io_error must include target path, got: {enriched}"
+        );
+        assert_eq!(
+            classify_error_kind(&enriched),
+            "filesystem_io_error",
+            "#130b: enriched messages must be classifier-recognizable"
+        );
+        // #130c: `claw diff --help` must route to help topic, not reject as extra args.
+        // Regression: `diff` was the outlier among local introspection commands
+        // (status/config/mcp all accepted --help) because its parser arm rejected
+        // all extra args before help detection could run.
+        let diff_help_action = parse_args(&[
+            "diff".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("diff --help must parse as help action");
+        assert!(
+            matches!(diff_help_action, CliAction::HelpTopic(LocalHelpTopic::Diff)),
+            "#130c: diff --help must route to LocalHelpTopic::Diff, got: {diff_help_action:?}"
+        );
+        let diff_h_action = parse_args(&[
+            "diff".to_string(),
+            "-h".to_string(),
+        ])
+        .expect("diff -h must parse as help action");
+        assert!(
+            matches!(diff_h_action, CliAction::HelpTopic(LocalHelpTopic::Diff)),
+            "#130c: diff -h (short form) must route to LocalHelpTopic::Diff"
+        );
+        // #130c: bare `claw diff` still routes to Diff action, not help.
+        let diff_action = parse_args(&[
+            "diff".to_string(),
+        ])
+        .expect("bare diff must parse as diff action");
+        assert!(
+            matches!(diff_action, CliAction::Diff { .. }),
+            "#130c: bare diff must still route to Diff action, got: {diff_action:?}"
+        );
+        // #130c: unknown args still rejected (non-regression).
+        let diff_bad_arg = parse_args(&[
+            "diff".to_string(),
+            "foo".to_string(),
+        ])
+        .expect_err("diff foo must still be rejected as extra args");
+        assert!(
+            diff_bad_arg.contains("unexpected extra arguments"),
+            "#130c: diff with unknown arg must still error, got: {diff_bad_arg}"
+        );
+        // #130d: `claw config --help` must route to help topic, not silently run config.
+        let config_help_action = parse_args(&[
+            "config".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("config --help must parse as help action");
+        assert!(
+            matches!(config_help_action, CliAction::HelpTopic(LocalHelpTopic::Config)),
+            "#130d: config --help must route to LocalHelpTopic::Config, got: {config_help_action:?}"
+        );
+        let config_h_action = parse_args(&[
+            "config".to_string(),
+            "-h".to_string(),
+        ])
+        .expect("config -h must parse as help action");
+        assert!(
+            matches!(config_h_action, CliAction::HelpTopic(LocalHelpTopic::Config)),
+            "#130d: config -h (short form) must route to LocalHelpTopic::Config"
+        );
+        // #130d: bare `claw config` still routes to Config action with no section
+        let config_action = parse_args(&[
+            "config".to_string(),
+        ])
+        .expect("bare config must parse as config action");
+        assert!(
+            matches!(config_action, CliAction::Config { section: None, .. }),
+            "#130d: bare config must still route to Config action with section=None"
+        );
+        // #130d: config with section still works (non-regression)
+        let config_section = parse_args(&[
+            "config".to_string(),
+            "permissions".to_string(),
+        ])
+        .expect("config permissions must parse");
+        assert!(
+            matches!(config_section, CliAction::Config { section: Some(ref s), .. } if s == "permissions"),
+            "#130d: config with section must still work"
+        );
+        // #130e: dispatch-order help fixes for help, submit, resume
+        // These previously emitted `missing_credentials` instead of showing help,
+        // because parse_local_help_action() didn't route them. Now they route
+        // to dedicated help topics before credential check.
+        let help_help = parse_args(&[
+            "help".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("help --help must parse as help action");
+        assert!(
+            matches!(help_help, CliAction::HelpTopic(LocalHelpTopic::Meta)),
+            "#130e: help --help must route to LocalHelpTopic::Meta, got: {help_help:?}"
+        );
+        let submit_help = parse_args(&[
+            "submit".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("submit --help must parse as help action");
+        assert!(
+            matches!(submit_help, CliAction::HelpTopic(LocalHelpTopic::Submit)),
+            "#130e: submit --help must route to LocalHelpTopic::Submit"
+        );
+        let resume_help = parse_args(&[
+            "resume".to_string(),
+            "--help".to_string(),
+        ])
+        .expect("resume --help must parse as help action");
+        assert!(
+            matches!(resume_help, CliAction::HelpTopic(LocalHelpTopic::Resume)),
+            "#130e: resume --help must route to LocalHelpTopic::Resume"
+        );
+        // Short form `-h` works for all three
+        let help_h = parse_args(&["help".to_string(), "-h".to_string()])
+            .expect("help -h must parse");
+        assert!(matches!(help_h, CliAction::HelpTopic(LocalHelpTopic::Meta)));
+        let submit_h = parse_args(&["submit".to_string(), "-h".to_string()])
+            .expect("submit -h must parse");
+        assert!(matches!(submit_h, CliAction::HelpTopic(LocalHelpTopic::Submit)));
+        let resume_h = parse_args(&["resume".to_string(), "-h".to_string()])
+            .expect("resume -h must parse");
+        assert!(matches!(resume_h, CliAction::HelpTopic(LocalHelpTopic::Resume)));
         // #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