@thedecipherist/claude-packs 0.0.0-stage → 1.1.0

package/packs/rust/checks/rust-stub-left-in.json

@@ -0,0 +1,32 @@
+{
+  "id": "rust-stub-left-in",
+  "why": "A stub or a debug print compiles, so it ships. `unimplemented!` stays allowed: it is a decision, not a leftover.",
+  "rule": ".claude/rules/rust-lints-are-the-gate.md",
+  "globs": [
+    "**/*.rs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/benches/**",
+    "**/examples/**",
+    "**/fixtures/**",
+    "**/test_data/**",
+    "**/testdata/**",
+    "**/fuzz/**",
+    "**/xtask/**",
+    "**/target/**",
+    "**/vendor/**",
+    "**/build.rs",
+    "**/tests.rs",
+    "**/test.rs",
+    "**/*_test.rs",
+    "**/*_tests.rs",
+    "**/test_*.rs"
+  ],
+  "language": "rust",
+  "notInTests": true,
+  "pattern": "\\b(?:todo|dbg)!\\s*[(\\[{]",
+  "bad": "fn load() -> Config { todo!() }",
+  "good": "fn load() -> Result<Config> { read_config() }"
+}

package/packs/rust/checks/rust-unsafe-needs-safety.json

@@ -0,0 +1,31 @@
+{
+  "id": "rust-unsafe-needs-safety",
+  "why": "An unsafe block with no stated reason cannot be reviewed.",
+  "rule": ".claude/rules/rust-unsafe-is-proved.md",
+  "globs": [
+    "**/*.rs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/benches/**",
+    "**/examples/**",
+    "**/fixtures/**",
+    "**/test_data/**",
+    "**/testdata/**",
+    "**/fuzz/**",
+    "**/xtask/**",
+    "**/target/**",
+    "**/vendor/**",
+    "**/build.rs",
+    "**/tests.rs",
+    "**/test.rs",
+    "**/*_test.rs",
+    "**/*_tests.rs",
+    "**/test_*.rs"
+  ],
+  "pattern": "^(?<!(?:^|\\n)[ \\t]*//[^\\n]*[Ss][Aa][Ff][Ee][Tt][Yy][^\\n]*\\n(?:[ \\t]*//[^\\n]*\\n)*)(?![ \\t]*//)(?![^\\n]*//[^\\n]*SAFETY)[^\\n]*\\bunsafe\\s*\\{",
+  "flags": "m",
+  "bad": "fn f(p: *const u8) -> u8 {\n    unsafe { *p }\n}",
+  "good": "fn f(p: *const u8) -> u8 {\n    // SAFETY: the caller passes a live pointer, checked in new().\n    unsafe { *p }\n}"
+}

package/packs/rust/checks/rust-unwrap-in-library.json

@@ -0,0 +1,34 @@
+{
+  "id": "rust-unwrap-in-library",
+  "why": "A failure the caller could handle becomes a panic with no reason. Return it with `?`, or say why it cannot happen with `.expect(\"...\")`.",
+  "rule": ".claude/rules/rust-errors-are-returned.md",
+  "globs": [
+    "**/*.rs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/benches/**",
+    "**/examples/**",
+    "**/fixtures/**",
+    "**/test_data/**",
+    "**/testdata/**",
+    "**/fuzz/**",
+    "**/xtask/**",
+    "**/target/**",
+    "**/vendor/**",
+    "**/build.rs",
+    "**/tests.rs",
+    "**/test.rs",
+    "**/*_test.rs",
+    "**/*_tests.rs",
+    "**/test_*.rs",
+    "**/main.rs",
+    "**/bin/**"
+  ],
+  "language": "rust",
+  "notInTests": true,
+  "pattern": "(?<!\\.lock\\(\\)|\\.read\\(\\)|\\.write\\(\\))\\.unwrap\\(\\)",
+  "bad": "let n = text.parse::<u32>().unwrap();",
+  "good": "let n = text.parse::<u32>()?;"
+}

package/packs/rust/checks/rust-wildcard-dependency.json

@@ -0,0 +1,16 @@
+{
+  "id": "rust-wildcard-dependency",
+  "why": "A * version takes whatever is newest, and crates.io refuses it.",
+  "rule": ".claude/rules/rust-lints-are-the-gate.md",
+  "globs": [
+    "**/Cargo.toml"
+  ],
+  "exclude": [
+    "**/target/**",
+    "**/vendor/**"
+  ],
+  "pattern": "(?:^[ \\t]*[\\w-]+\\s*=\\s*|\\bversion\\s*=\\s*)\"\\*\"",
+  "flags": "m",
+  "bad": "serde = \"*\"",
+  "good": "serde = \"1.0\""
+}

package/packs/rust/clippy.toml

@@ -0,0 +1,5 @@
+# Unit tests live in the file they test: the lints that hold library code leave them alone.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-dbg-in-tests = true
+allow-panic-in-tests = true

package/packs/rust/pack.json

@@ -0,0 +1,27 @@
+{
+  "name": "rust",
+  "version": "1.0.0",
+  "description": "Rust: errors returned, unsafe proved, async never blocks, clippy as the gate. What clippy reads better stays with clippy.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/rust"
+  },
+  "keywords": [
+    "rust",
+    "cargo",
+    "clippy"
+  ],
+  "engines": {
+    "claude-packs": ">=1.1.0"
+  },
+  "concepts": {
+    "rust": [
+      "**/*.rs"
+    ]
+  }
+}

package/packs/rust/rules/rust-async-never-blocks.md

@@ -0,0 +1,20 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# An async function never blocks its thread
+
+<constraints>
+Always do:
+- Hand blocking work to `spawn_blocking`, or use the runtime's own `fs`, `process` and `time`.
+- Drop a `std::sync` guard before an `.await`. Use the runtime's own mutex when the lock must span one.
+- Give every spawned task a way to stop, and a place its error lands.
+
+Never do:
+- Call `std::thread::sleep`, `std::fs` or `std::process::Command` in an `async fn`.
+- Hold a lock across `.await`: clippy's `await_holding_lock` reads this, and the gate holds it.
+</constraints>
+
+## Check
+`rust-blocking-in-async`.

package/packs/rust/rules/rust-borrow-before-you-clone.md

@@ -0,0 +1,19 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# Borrow first: a clone is a decision, never a way past the borrow checker
+
+<constraints>
+Always do:
+- Take `&str`, `&[T]` and `&Path` in a parameter, and own only what is kept.
+- When the borrow checker refuses, change who owns the value, or shorten the borrow.
+- Use `impl Trait` or a generic before `Box<dyn Trait>`, unless the types differ at run time.
+- Walk with iterators. Let lifetimes be elided where the compiler allows it.
+- Give a value its own type (a newtype, an enum) in place of a bare `String` or a `bool` flag.
+
+Never do:
+- Add `.clone()`, `Rc` or `RefCell` only to make an error go away.
+- Write a function again in another crate: `template-law` reads Rust. The `rust-extract-template` skill has the forms.
+</constraints>

package/packs/rust/rules/rust-errors-are-returned.md

@@ -0,0 +1,22 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# An error is returned; a panic states why it cannot happen
+
+<constraints>
+Always do:
+- Return `Result` from anything that can fail, and pass it up with `?`.
+- Give a library its own error type, by hand or with `thiserror`, so a caller can match on it.
+- In an application, use `anyhow` with `.context(...)` saying what was being attempted.
+- Write `.expect("why this cannot fail")` for a true invariant. The message is the proof.
+
+Never do:
+- `.unwrap()` in library code. Tests, `main.rs` and `src/bin/` may.
+- Return `Result<T, String>` or `Box<dyn Error>` from a public function.
+- Drop a `Result` with `let _ =` on a state change.
+</constraints>
+
+## Check
+`rust-unwrap-in-library`, `rust-string-as-error`.

package/packs/rust/rules/rust-lints-are-the-gate.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# `cargo clippy -D warnings` and `cargo fmt --check` are the gate
+
+Clippy reads types, so what it can judge stays with it. The lesson checks stop only what is cheaper to stop at the write.
+
+<constraints>
+Always do:
+- Take the lint set in `.claude/tools/rust-lints.toml` into `Cargo.toml`, and keep the installed `clippy.toml` at the root.
+- Run `cargo fmt --check`, then `cargo clippy --all-targets --all-features -- -D warnings`, before landing.
+- Turn a lint off with `#[expect(lint, reason = "...")]`, on the smallest item. `reason` needs Rust 1.81; on an older toolchain, disable `checks/rust-allow-needs-reason.json` in `layout.json`.
+- Commit `Cargo.lock` for an application.
+
+Never do:
+- Leave `todo!()` or `dbg!()` in code that lands. `unimplemented!()` is a decision, and may stay.
+- Depend on a `*` version.
+</constraints>
+
+## Check
+`rust-allow-needs-reason`, `rust-stub-left-in`, `rust-wildcard-dependency`.

package/packs/rust/rules/rust-repeats-become-templates.md

@@ -0,0 +1,28 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# Anything repeated in Rust becomes one template: pick the form that fits the repeat
+
+<constraints>
+Always do:
+- Match the repeat to its form. The `rust-extract-template` skill has each with an example:
+  - A block with other names: one function, with what differs as parameters.
+  - The same code over several types: a generic with a trait bound.
+  - The same method on many types: a trait with a default method.
+  - The same `impl` for many types, where a generic cannot do it: one `macro_rules!`.
+  - One call repeated with other arguments: a `const` table and one loop.
+  - The same code in two crates: the crate both depend on.
+- Give an enum its own methods for what varies by variant: `state.label()`, in the enum's impl. A table of values on an enum belongs with the enum.
+- Match every variant by name, so a new variant is a compile error in each place that must decide. `clippy::wildcard_enum_match_arm` holds this.
+- Use `#[derive(...)]` and `thiserror`'s `#[from]` in place of hand-written impls.
+
+Never do:
+- Write `_ =>` on your own enum: it hides the next variant from the compiler.
+- Write a macro where a function or a generic does the job, or a trait with one implementor.
+- Treat a trait method as a copy: `from_str` on two types is the trait doing its job.
+</constraints>
+
+## Check
+`template-law` refuses a copy, a near copy, a table written as calls and a function made again. `dispatch-once` refuses a second lookup table on one enum outside the enum's own file. `once-only` refuses a copy as written. `rust-if-chain-is-a-match` refuses three `==` branches on one value.

package/packs/rust/rules/rust-unsafe-is-proved.md

@@ -0,0 +1,21 @@
+---
+paths:
+  - "**/*.rs"
+---
+
+# Every unsafe block says why it is sound
+
+<constraints>
+Always do:
+- Put a `// SAFETY:` comment directly above each `unsafe` block, naming the invariant and what upholds it.
+- Keep a block to one unsafe operation, and wrap it in a safe function that checks what it needs.
+- Give every `unsafe fn` a `# Safety` section in its docs.
+- Run `cargo miri test` on code with `unsafe`, where it can run.
+
+Never do:
+- Use `static mut`: use an atomic, `OnceLock` or a `Mutex`.
+- Use `unsafe` for speed with no measurement showing the safe form is too slow.
+</constraints>
+
+## Check
+`rust-unsafe-needs-safety`, `rust-static-mut`.

package/packs/rust/skills/rust-extract-template/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: rust-extract-template
+description: Use when template-law refuses Rust code, when scan lists repeated Rust, or when copying a Rust function, impl or module to change it.
+---
+
+# Extract a Rust repeat into one template (one job: pick the Rust form, and move every copy to it)
+
+Follow `make-it-a-template`. This skill is its Rust forms.
+
+<constraints>
+Always do:
+1. A repeated block: one function, with what differs as parameters. A difference in behaviour is a closure parameter.
+2. The same code over several types: a generic with a trait bound.
+   ```rust
+   fn total<T: Priced>(items: &[T]) -> u64 {
+       items.iter().map(Priced::price).sum()
+   }
+   ```
+3. The same method on many types: a trait with a default method.
+4. The same `impl` written for many types: one `macro_rules!`, and only when a generic cannot do it.
+   ```rust
+   macro_rules! impl_id { ($($t:ident),*) => { $(impl Id for $t { fn raw(&self) -> u64 { self.0 } })* } }
+   impl_id!(UserId, OrderId);
+   ```
+5. One call with other arguments: a `const` table and one loop.
+   ```rust
+   const ROUTES: &[(&str, Handler)] = &[("/users", users), ("/orders", orders)];
+   for (path, handler) in ROUTES {
+       app.route(path, *handler);
+   }
+   ```
+6. A table of values on an enum: a method on the enum, in its own impl, with every variant named. `dispatch-once` refuses a second table outside it.
+   ```rust
+   impl State {
+       pub fn colour(&self) -> u32 {
+           match self {
+               State::Open => 1,
+               State::Closed => 4,
+           }
+       }
+   }
+   ```
+7. Fields that travel together: a struct, with `#[derive(...)]` in place of hand-written impls. A run of `impl From<X> for MyError`: `thiserror`'s `#[from]`.
+8. The same code in two crates: move it to the crate both depend on.
+9. Run what the change reaches: `cargo test -p <crate>`. Then search for the old names: none is left.
+
+Never do:
+- Write a macro where a function or a generic does the job.
+- Add a trait with one implementor.
+</constraints>

package/packs/rust/skills/rust-port/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: rust-port
+description: Use when porting code to Rust from another language, or rewriting a module in Rust.
+---
+
+# Port to Rust (one job: the same behaviour, in Rust's own shapes)
+
+<constraints>
+Always do:
+1. Pin the behaviour first: tests or recorded input and output from the old code, kept as the proof.
+2. Write down who owns each piece of state. A shared mutable object becomes one owner that lends, or a message to the task that owns it.
+3. Map each failure the old code can have to a variant of an error type. An exception becomes a `Result`; a null becomes an `Option`.
+4. Map an inheritance tree to an enum when the set of kinds is closed, and to a trait when it is open.
+5. Port one module at a time behind the same interface, and run the pinned tests after each.
+6. Keep a behaviour the old code has even if it looks wrong, and list it. Change it in its own step.
+7. Compare speed only after it is correct, on a release build.
+
+Never do:
+- Translate line by line: a class with getters and shared pointers everywhere is the old language in Rust's syntax.
+- Reach for `Rc<RefCell<T>>` or `unsafe` to keep the old shape.
+- Change behaviour and language in the same step.
+</constraints>

package/packs/rust/skills/rust-review/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: rust-review
+description: Use when reviewing Rust code, a Rust diff or a crate before it lands, or when asked whether Rust code is sound or idiomatic.
+---
+
+# Review Rust (one job: find what the compiler and clippy cannot)
+
+Run the gate first, so the review spends nothing on what tools already say: `cargo fmt --check`, `cargo clippy --all-targets --all-features -- -D warnings`, `cargo test`.
+
+<constraints>
+Always do:
+1. Ownership: is each `.clone()`, `Rc`, `Arc` and `RefCell` needed, or was it a way past a borrow error? Could the caller keep the value and lend it?
+2. Errors: can a caller tell the failures apart? Is every `.expect` message a true invariant? Does a `?` lose what was being attempted?
+3. `unsafe`: does each `SAFETY` comment name a real invariant, and does the code around it uphold that? Read the callers. Check aliasing, alignment, initialization, and that a panic in the block leaves nothing half done.
+4. Concurrency: what happens when a future is dropped at each `.await`? Is state left half written? Is a channel unbounded? Is `Ordering::Relaxed` proved enough?
+5. Public API: would a new field or variant break a caller (`#[non_exhaustive]`)? Is an internal type exposed? Are `Send` and `Sync` what the caller needs?
+6. Numbers and text: an `as` cast that truncates, an overflow in release builds, a byte index into a `&str`.
+7. Tests: does a test fail without the change? Is an error path covered, not only the happy one?
+8. Report each finding with the file, the symbol and the input that breaks it. A finding you cannot give an input for is a question.
+
+Never do:
+- Report what clippy or `rustfmt` already says.
+- Ask for a lifetime, a trait or a generic the code does not need.
+</constraints>

package/packs/rust/tools/rust-lints.toml

@@ -0,0 +1,19 @@
+# The gate's lint set: paste it into Cargo.toml. In a workspace, write [workspace.lints.rust] and [workspace.lints.clippy]
+# at the root, and `[lints] workspace = true` in each crate. An application can drop unwrap_used from main.rs with an
+# `#[expect(clippy::unwrap_used, reason = "...")]`. `reason` needs Rust 1.81.
+[lints.rust]
+unsafe_op_in_unsafe_fn = "deny"
+
+[lints.clippy]
+all = { level = "deny", priority = -1 }
+unwrap_used = "deny"
+todo = "deny"
+dbg_macro = "deny"
+allow_attributes_without_reason = "deny"
+undocumented_unsafe_blocks = "deny"
+multiple_unsafe_ops_per_block = "deny"
+panic_in_result_fn = "deny"
+redundant_clone = "deny"
+clone_on_ref_ptr = "deny"
+fn_params_excessive_bools = "deny"
+wildcard_enum_match_arm = "deny"

package/packs/shell/checks/sh-mktemp.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-mktemp",
+  "why": "A fixed path in /tmp collides with another run, and another user can plant it.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": ">>?\\s*\\\"?/tmp/\\w",
+  "flags": "m",
+  "bad": "echo x > /tmp/out.txt",
+  "good": "out=$(mktemp)\necho x > \"$out\""
+}

package/packs/shell/checks/sh-no-backticks.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-no-backticks",
+  "why": "Backticks do not nest and hide in quoted text. $(...) does the same thing, and reads.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^[^#'\\n]*`[^`\\n]+`",
+  "flags": "m",
+  "bad": "now=`date`",
+  "good": "now=$(date)"
+}

package/packs/shell/checks/sh-no-eval.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-no-eval",
+  "why": "eval runs whatever a variable holds, with the script's rights.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^[^#\\n]*(?:^|[;&|\\s])eval\\s",
+  "flags": "m",
+  "bad": "eval \"$cmd\"",
+  "good": "\"$@\""
+}

package/packs/shell/checks/sh-no-parse-ls.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-no-parse-ls",
+  "why": "ls output breaks on spaces and newlines. A glob does not.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\bfor\\s+\\w+\\s+in\\s+\\$\\(\\s*ls\\b|\\bls\\b[^|\\n]*\\|\\s*(?:while|xargs)\\b",
+  "flags": "m",
+  "bad": "for f in $(ls *.txt); do echo \"$f\"; done",
+  "good": "for f in *.txt; do echo \"$f\"; done"
+}

package/packs/shell/checks/sh-no-pipe-to-shell.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-no-pipe-to-shell",
+  "why": "A download piped into a shell runs whatever the server sends, unread.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\b(?:curl|wget)\\b[^\\n|]*\\|\\s*(?:sudo\\s+)?(?:ba|z|da)?sh\\b",
+  "flags": "m",
+  "bad": "curl -fsSL https://example.com/i.sh | sh",
+  "good": "curl -fsSL -o i.sh https://example.com/i.sh"
+}

package/packs/shell/checks/sh-no-program-in-heredoc.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-no-program-in-heredoc",
+  "why": "A program in a heredoc cannot be linted, tested or reused. Give it its own file and call it.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\b(?:python3?|node|ruby|perl)\\s+(?:-\\w+\\s+)*-(?:\\s[^\\n]*)?<<",
+  "flags": "m",
+  "bad": "python3 - \"$out\" <<'EOF'\nprint(1)\nEOF",
+  "good": "python3 tools/read_out.py \"$out\""
+}

package/packs/shell/checks/sh-quote-arguments.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-quote-arguments",
+  "why": "An unquoted variable splits on spaces and expands globs, so a path with a space becomes two arguments.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^[^#\\\"'\\n]*\\b(?:cp|mv|rm|cat|cd|mkdir|touch|chmod|chown|source)\\s+[^\\\"'\\n#]*\\$[A-Za-z_{]",
+  "flags": "m",
+  "bad": "cp $src $dst",
+  "good": "cp \"$src\" \"$dst\""
+}

package/packs/shell/checks/sh-rm-guarded.json

@@ -0,0 +1,18 @@
+{
+  "id": "sh-rm-guarded",
+  "why": "An empty variable turns `rm -rf \"$dir/\"` into a delete from the root. `${dir:?}` stops the script instead.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\brm\\s+-[a-zA-Z]*[rR][a-zA-Z]*\\s+\\\"?\\$\\{?\\w+(?!\\w*:\\?)\\}?",
+  "flags": "m",
+  "bad": "rm -rf \"$dir/build\"",
+  "good": "rm -rf \"${dir:?}/build\""
+}

package/packs/shell/checks/sh-strict-mode.json

@@ -0,0 +1,20 @@
+{
+  "id": "sh-strict-mode",
+  "why": "Without strict mode a failed step is ignored and the script carries on with bad state. A file only sourced is left out.",
+  "rule": ".claude/rules/shell-strict-and-quoted.md",
+  "concepts": [
+    "shell"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "pattern": "^#![^\\n]*\\b(?:ba|z|da)?sh\\b",
+  "flags": "m",
+  "bad": "#!/usr/bin/env bash\nset -u\necho done",
+  "good": "#!/usr/bin/env bash\nset -euo pipefail\necho done\n",
+  "mode": "needs",
+  "needs": [
+    "^\\s*set\\s+-\\w*e\\w*(?:\\s+-o\\s+pipefail|\\w*o\\s+pipefail)"
+  ]
+}

package/packs/shell/pack.json

@@ -0,0 +1,28 @@
+{
+  "name": "shell",
+  "version": "1.0.0",
+  "description": "Shell scripts: strict mode, quoted arguments, shared functions in one sourced file, tables and loops, and programs kept out of heredocs.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/shell"
+  },
+  "keywords": [
+    "shell",
+    "bash"
+  ],
+  "engines": {
+    "claude-packs": ">=0.25.0"
+  },
+  "concepts": {
+    "shell": [
+      "**/*.sh",
+      "**/*.bash",
+      "**/*.zsh"
+    ]
+  }
+}

package/packs/shell/rules/shell-repeats-become-templates.md

@@ -0,0 +1,23 @@
+---
+# concepts: shell
+paths:
+  - "placeholder"
+---
+
+# Anything repeated in shell becomes a template: a function in one sourced file, or a table and a loop
+
+Measured on real repos: the same wait-and-check block in five gate scripts, the same retry and logging at the top of every hook, and one command written out dozens of times with other arguments.
+
+<constraints>
+Always do:
+- Put what scripts share in one file they source: logging, waiting, cleanup, argument checks. `. "$(dirname "$0")/lib.sh"`.
+- Turn one command repeated with other arguments into an array of rows and one loop, or a function called from a table.
+- Start a new script from the shared file: it holds only what this script does.
+
+Never do:
+- Copy a script to start the next one.
+- Paste the same `if` or `trap` block at the top of each script.
+</constraints>
+
+## Check
+`template-law` refuses a new copy, a near copy or a function the repo already has. The `shell-extract-template` skill walks the change.