@thedecipherist/claude-packs 0.0.0-stage → 1.0.0

package/packs/dynamic-data/checks/no-collection-from-request.json

@@ -0,0 +1,27 @@
+{
+  "id": "no-collection-from-request",
+  "why": "A collection named by the request reaches every collection. Resolve it through an allowlist, switched on.",
+  "rule": ".claude/rules/every-dynamic-surface-has-a-boundary.md",
+  "globs": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/e2e/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**"
+  ],
+  "pattern": "\\.collection\\(\\s*(?:req|request|ctx)\\.(?:params|query|body)\\b|\\.collection\\(\\s*params\\.\\w+",
+  "bad": "const rows = await db.collection(req.params.collection).find({}).toArray();",
+  "good": "const def = definitions.get(req.params.collection);\nconst rows = await gateway.find(def, scope);",
+  "kind": "security"
+}

package/packs/dynamic-data/checks/no-pipeline-from-stored-text.json

@@ -0,0 +1,27 @@
+{
+  "id": "no-pipeline-from-stored-text",
+  "why": "A pipeline parsed from stored text runs with no schema, no allowlist and no tenant filter. Compile it from a validated expression tree.",
+  "rule": ".claude/rules/every-dynamic-surface-has-a-boundary.md",
+  "globs": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/e2e/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**"
+  ],
+  "pattern": "\\.aggregate\\(\\s*JSON\\.parse\\(",
+  "bad": "const rows = await col.aggregate(JSON.parse(query.pipeline)).toArray();",
+  "good": "const rows = await gateway.run(compile(query.tree), scope);",
+  "kind": "security"
+}

package/packs/dynamic-data/checks/no-regexp-from-stored-config.json

@@ -0,0 +1,27 @@
+{
+  "id": "no-regexp-from-stored-config",
+  "why": "A pattern from stored config runs in the regex engine with no boundary, and a bad one hangs the process. Declare validation as checked data, compiled into the schema.",
+  "rule": ".claude/rules/every-dynamic-surface-has-a-boundary.md",
+  "globs": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/e2e/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**"
+  ],
+  "pattern": "\\bnew\\s+RegExp\\s*\\(\\s*[\\w.]*(?:config|field|definition|setting|rule|requirements?)\\w*\\.[\\w.]*",
+  "bad": "const re = new RegExp(field.config.requirements, \"g\");",
+  "good": "const schema = compileField(field);\nconst re = new RegExp(escapeRe(term));",
+  "kind": "security"
+}

package/packs/dynamic-data/checks/no-template-from-stored-text.json

@@ -0,0 +1,27 @@
+{
+  "id": "no-template-from-stored-text",
+  "why": "A template engine fed from stored text makes template edit rights equal code execution. Render against a declared context, with no code in the template.",
+  "rule": ".claude/rules/every-dynamic-surface-has-a-boundary.md",
+  "globs": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/e2e/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**"
+  ],
+  "pattern": "\\b(?:_\\.template|ejs\\.render|ejs\\.compile|Handlebars\\.compile|nunjucks\\.renderString|pug\\.render|pug\\.compile)\\(\\s*(?!['\\\"`])",
+  "bad": "const html = _.template(doc.body)(context);",
+  "good": "const html = renderBlocks(doc.blocks, context);\nconst tpl = _.template('<b>fixed</b>');",
+  "kind": "security"
+}

package/packs/dynamic-data/checks/save-takes-named-paths.json

@@ -0,0 +1,27 @@
+{
+  "id": "save-takes-named-paths",
+  "why": "A save that takes the whole body is mass assignment: any field a client sends is written, whatever its role may touch. Check the paths against what the role may write.",
+  "rule": ".claude/rules/rules-live-in-the-engine.md",
+  "globs": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/e2e/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**"
+  ],
+  "pattern": "\\.(?:updateOne|updateMany|findOneAndUpdate|findByIdAndUpdate)\\([^;]*\\$set\\s*:\\s*(?:req|request)\\.body\\b|\\.(?:insertOne|replaceOne)\\([^;]*(?:req|request)\\.body\\s*\\)",
+  "bad": "await col.updateOne({ _id: id }, { $set: req.body });",
+  "good": "await write(entity, id, patch, { role, scope });",
+  "kind": "security"
+}

package/packs/dynamic-data/pack.json

@@ -0,0 +1,23 @@
+{
+  "name": "dynamic-data",
+  "version": "1.0.0",
+  "description": "Systems driven by definitions: a CMS, an admin generator, a low-code platform. One definition drives every surface, the engine enforces and the UI only reflects, every dynamic surface has a boundary, and nothing an import brings is dropped silently.",
+  "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/dynamic-data"
+  },
+  "keywords": [
+    "cms",
+    "admin",
+    "metadata",
+    "low-code"
+  ],
+  "engines": {
+    "claude-packs": ">=0.26.0"
+  }
+}

package/packs/dynamic-data/rules/a-list-is-a-saved-query.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# A list, a filter, a chart and a dashboard tile are one saved query
+
+<constraints>
+Always do:
+- Make the filter UI edit an expression tree. Ad-hoc filter state is an unsaved query.
+- Make a saved view a named query, with a column set and a page size.
+- Point lists, charts, tiles and page blocks at the same named query.
+- Build the list destination first: it is what people live in.
+- Serve filter suggestions from indexed, tenant-scoped, limited queries.
+
+Never do:
+- Make a second filter language for one surface.
+- Scan a whole collection with `distinct` for suggestions.
+</constraints>

package/packs/dynamic-data/rules/definitions-are-validated-data.md

@@ -0,0 +1,24 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# A definition is data, and it is validated on every save
+
+<constraints>
+Always do:
+- Validate every definition against a meta-schema when it is saved: the schema of a definition.
+- Hold platform entities in static schemas, and compile domain schemas from definitions at run time, cached.
+- Stamp each compiled artifact and each write's audit record with the definition version it was made under, and check that version before commit, so drift between processes is seen.
+- Check references both ways: a page that names a missing field fails on save, and a definition that renames a field used by a page fails or warns on save.
+- Resolve widgets, blocks, providers and hooks through a registry by name. An unknown name throws.
+- Let every producer of definitions (a person, a scaffolder, an agent) emit the same validated document.
+
+Never do:
+- Ship a definition language with no schema: `defaultSort` and `defaultSorts` in two shapes is what that looks like.
+- Invent a second config language for one idea.
+</constraints>

package/packs/dynamic-data/rules/every-dynamic-surface-has-a-boundary.md

@@ -0,0 +1,29 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# Configurable is never unbounded: every dynamic surface has a declared boundary
+
+<constraints>
+Always do:
+- Express conditions in one closed language: `{field, op, value}` leaves with `and`, `or`, `not`. Nothing executes, so nothing can be injected.
+- Compile it to the database on the query surface, and interpret it in the UI. Use the same language for visibility, validation, guards and filters.
+- Give the closed language a pressure valve: a named predicate from the registry, declared per surface.
+- Allowlist collections, operations and fields, and ship the allowlist switched on.
+- Validate a stored query at execution, and scope it to the tenant.
+- Render templates against a declared context schema, with no code in them.
+
+Never do:
+- Run text as code: `new Function`, `eval`, or a template engine fed from stored text. Template edit rights then equal code execution.
+- Build a `RegExp` from stored config.
+- Take a collection name from a request.
+- Filter in memory after a query: it breaks pagination and counts.
+</constraints>
+
+## Check
+`no-code-from-data`, `no-template-from-stored-text`, `no-regexp-from-stored-config`, `no-collection-from-request`, `no-pipeline-from-stored-text`.

package/packs/dynamic-data/rules/fields-have-owners.md

@@ -0,0 +1,22 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# Every field has an owner, and a human edit wins over an import
+
+<constraints>
+Always do:
+- Declare each field's owner: a user, the system, or an integration by name. Lock what an integration owns.
+- Set a `touched` latch when a human edits. An import stops updating that record or field until the latch is cleared, and the latch is visible.
+- Show who last changed a value.
+- Let a hook run with system authority, and record the actor chain.
+
+Never do:
+- Let a nightly sync overwrite a human's edit.
+- Let two systems both think they own one field.
+</constraints>

package/packs/dynamic-data/rules/imports-drop-nothing.md

@@ -0,0 +1,26 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# An import drops nothing silently, and every run can be traced
+
+<constraints>
+Always do:
+- Keep the field mapping as data: source, target, type, default, conditions, error policy.
+- Quarantine a row that cannot map, with the raw input, the attempt, the error and the batch id. A notice clears itself when the data heals.
+- Thread one batch id through every worker, log line and message.
+- Write what a batch will do before doing it, so a run can be replayed.
+- Guard invariants between systems: an external change to a settled record is quarantined, never applied.
+- Take a lock for a run, and release it on every exit path.
+- Rate limit third parties, and stop retrying what will keep failing.
+
+Never do:
+- Catch a mapping error and carry on with blanks.
+- Hardcode a list of exceptions in a transform: an exemption is data with an audit trail.
+- Build a query by string concatenation.
+</constraints>

package/packs/dynamic-data/rules/one-definition-many-surfaces.md

@@ -0,0 +1,24 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# A field is declared once, and every surface comes from that definition
+
+<constraints>
+Always do:
+- Keep one definition per entity. A field has its key, label, type, owner and access there, once.
+- Give a surface an overlay on that field (`grid`, `editor`, `api`, `import`) that holds what only that surface needs.
+- Generate the rest from the definition: schema, validation, API, response projection, audit.
+- Keep layout in pages, and semantics in the definition.
+- Render an entity with no custom layout from a virtual default, made at render time. It cannot drift, and a new field always appears.
+- Show a customised page's unplaced fields, so a new field is never silently missing from a form.
+
+Never do:
+- Keep two collections or files that describe the same field. Parallel `grid_fields` and `editor_fields` always drift.
+- Hand-write a per-entity branch in a generic screen. A generic editor with `if (entity === 'x')` is an if-chain with extra steps.
+</constraints>

package/packs/dynamic-data/rules/one-fact-one-place.md

@@ -0,0 +1,28 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# A fact is stored once, and what is derived is never stored beside it
+
+<constraints>
+Always do:
+- Store the source, and treat compiled output as a cache keyed by content.
+- Keep computed values in a reserved namespace on outgoing objects, so a reader can tell stored from derived.
+- Derive URLs from stable fields, and keep a ledger of renames so old URLs still resolve.
+- Key everything on immutable ids.
+- Project every response through an allowlist of fields.
+- Store a design token reference, so a retheme restyles everything. Flag a raw value as off-theme.
+
+Never do:
+- Persist editor state in content: selection, open panels, icons.
+- Store a model and its compiled output side by side.
+- Use a display name as a tenant key or a join key: a rename orphans the data.
+</constraints>
+
+## Check
+`key-is-not-a-display-name`.

package/packs/dynamic-data/rules/rules-live-in-the-engine.md

@@ -0,0 +1,29 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# The engine enforces, and the UI only reflects
+
+<constraints>
+Always do:
+- Keep one write path, so audit, policies and validation cannot be skipped.
+- Check every write against the role's writable paths on the server. Reject with the offending paths named.
+- Evaluate permissions per request, from current definitions.
+- Require the tenant scope as an argument of the data gateway, so no query can leave it out.
+- Run the same validation in the UI for instant feedback, from the same schema. It is never the gate.
+- Audit every write, with the actor chain: a hook's change names the user and the hook.
+
+Never do:
+- Enforce a permission or a required field only in the browser.
+- Snapshot permissions at login: a revoked right survives until logout.
+- Silently strip a disallowed field. Rejecting keeps the user's intent visible.
+- Accept the whole request body on a generic save.
+</constraints>
+
+## Check
+`save-takes-named-paths`, `guard-does-its-job`.

package/packs/dynamic-data/rules/saves-are-patches.md

@@ -0,0 +1,28 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# A save is a patch of changed paths, with a base version
+
+<constraints>
+Always do:
+- Send only the changed paths, validated by a partial schema.
+- Send the base version, and detect conflicts per field, so edits that do not overlap both land.
+- Feed the audit diff from the patch.
+- Make undo the inverse patch.
+- Keep drafts and unsaved filters on the server per user, so they follow the user across devices.
+- Keep only real session state in the browser, such as the open tab.
+
+Never do:
+- Save the whole document: the last writer wins, and silently undoes the other edit.
+- Snapshot whole documents for undo: it gets too heavy, and then it gets turned off.
+- Keep a draft in `localStorage`: it is a second, device-local truth.
+</constraints>
+
+## Check
+`draft-on-the-server`.

package/packs/dynamic-data/rules/tenant-costs-one-document.md

@@ -0,0 +1,22 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.js"
+  - "**/*.mjs"
+  - "**/*.cjs"
+---
+
+# A new tenant costs one document: no files, no builds
+
+<constraints>
+Always do:
+- Resolve the tenant at run time, from the request.
+- Hold everything a tenant is as data, with a declared override order: tenant, then platform default.
+- Emit theme values as CSS custom properties at run time.
+- Measure a feature by this number: anything that raises it is wrong.
+
+Never do:
+- Keep a folder or a build output per tenant.
+- Put tenant names or tokens in source.
+</constraints>

package/packs/dynamic-data/skills/design-a-definition/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: design-a-definition
+description: Use when designing an entity, a field, a screen or a generic admin in a definition-driven system, or when a CMS needs a new kind of thing.
+---
+
+# Design a definition (one job: the new thing is data, and every surface comes from it)
+
+<constraints>
+Always do:
+1. Write the entity as one definition: its collection, its tenant chain, and each field once with key, label, type, owner and access.
+2. Add overlays only for what a surface needs. Layout belongs in pages.
+3. Name each field's owner: a user, the system, or an integration. Decide what the `touched` latch protects.
+4. Write lifecycle guards as data: "cannot enable until these are filled".
+5. Write conditions in the one expression language. Reach for a named predicate only when the language cannot say it.
+6. Attach behaviour as named hooks on the one write path, and declare whether each observes or changes the patch.
+7. Validate it against the meta-schema, and check what references it, both ways.
+8. Prove it on the hardest real entity you have, not a sample. Then check the cost of a new tenant is still one document.
+
+Never do:
+- Add code for something a definition can say.
+- Add a per-entity branch to a generic screen.
+- Add a config language.
+- Let a page grant access: it can only show what the engine allows.
+</constraints>

package/packs/fastify/checks/api-routes-versioned.json

@@ -0,0 +1,28 @@
+{
+  "id": "api-routes-versioned",
+  "why": "An unversioned API route cannot change without breaking every client. /api/v1/ from the first line.",
+  "rule": ".claude/rules/three-layers.md",
+  "concepts": [
+    "routes"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**",
+    "**/ui/**",
+    "**/auth/**",
+    "**/health*",
+    "**/app/api/**"
+  ],
+  "code": false,
+  "pattern": "\\.(?:get|post|put|patch|delete|route)\\s*\\(\\s*['\\\"`]/api/(?!v\\d+/)",
+  "bad": "app.get('/api/sessions', handler);",
+  "good": "app.get('/api/v1/sessions', handler);"
+}

package/packs/fastify/checks/cookie-host-prefix.json

@@ -0,0 +1,24 @@
+{
+  "id": "cookie-host-prefix",
+  "why": "A session cookie without the __Host- prefix can be set by a subdomain or over plain HTTP. __Host- forces secure, path=/ and no domain.",
+  "rule": ".claude/rules/trust-config-not-headers.md",
+  "concepts": [
+    "routes"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "code": false,
+  "pattern": "\\bsetCookie\\s*\\(\\s*['\\\"](?!__Host-)",
+  "bad": "reply.setCookie('ui_session', token, { httpOnly: true, path: '/ui' });",
+  "good": "reply.setCookie('__Host-session', token, { httpOnly: true, secure: true, path: '/', sameSite: 'lax' });"
+}

package/packs/fastify/checks/hijack-needs-try.json

@@ -0,0 +1,28 @@
+{
+  "id": "hijack-needs-try",
+  "why": "After reply.hijack() Fastify's error handler cannot answer; a throw leaves the socket open forever. Wrap what follows in try/catch that ends the raw response.",
+  "rule": ".claude/rules/streams-and-hijacks.md",
+  "concepts": [
+    "routes"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "code": true,
+  "mode": "needs",
+  "pattern": "\\.hijack\\s*\\(\\s*\\)",
+  "needs": [
+    "\\btry\\s*\\{"
+  ],
+  "bad": "reply.hijack();\nconst stop = await streamChanges(raw, session._id);",
+  "good": "reply.hijack();\ntry { await streamChanges(raw, session._id); } catch (err: unknown) { log.error({ err }, 'sse failed'); raw.end(); }"
+}

package/packs/fastify/checks/no-cast-at-route-boundary.json

@@ -0,0 +1,24 @@
+{
+  "id": "no-cast-at-route-boundary",
+  "why": "`req.body as {\u2026}` and String(body.x) are not validation: a missing or malformed field reaches the handler as undefined or 'undefined'. safeParse with the entity schema, 400 on failure.",
+  "rule": ".claude/rules/trust-config-not-headers.md",
+  "concepts": [
+    "routes"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "code": true,
+  "pattern": "\\b(?:req|request)\\.(?:body|query|params)\\s+as\\b|\\b(?:String|Number|Boolean)\\(\\s*(?:req|request)?\\.?(?:body|query|params)\\b[\\w.]*\\s*[)?]",
+  "bad": "const body = req.body as { name: string };\nconst page = Number(query.page);",
+  "good": "const parsed = LoginInput.safeParse(req.body);\nif (!parsed.success) return reply.code(400).send(badRequest(parsed.error));"
+}

package/packs/fastify/checks/no-db-in-route-file.json

@@ -0,0 +1,28 @@
+{
+  "id": "no-db-in-route-file",
+  "why": "A route file is request-in, handler-call, response-out. A collection call or external fetch here is business logic in the wrong layer; move it to handlers/ and adapters/.",
+  "rule": ".claude/rules/three-layers.md",
+  "globs": [
+    "**/routes/**",
+    "**/app/api/**/route.ts",
+    "**/app.ts",
+    "**/server.ts",
+    "**/ui/**/*.ts"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "code": true,
+  "pattern": "\\.(?:aggregate|insertOne|insertMany|updateOne|updateMany|deleteOne|deleteMany|bulkWrite|findOneAndUpdate|countDocuments)\\s*\\(|\\bcollection\\s*\\(",
+  "bad": "app.get('/api/v1/sessions', async () => sessionsCollection().aggregate([{ $match: { deleted: false } }]).toArray());",
+  "good": "app.get('/api/v1/sessions', async (req) => listSessions(parse(req)));"
+}

package/packs/fastify/checks/no-err-message-to-client.json

@@ -0,0 +1,24 @@
+{
+  "id": "no-err-message-to-client",
+  "why": "err.message in a response leaks hostnames, index names and connection detail. The client gets a controlled message or a correlation id; the stack goes to the log.",
+  "rule": ".claude/rules/security-one-switch.md",
+  "concepts": [
+    "routes"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "code": true,
+  "pattern": "\\b(?:message|error|detail)\\s*:\\s*(?:err|error|e|ex)\\.message\\b|\\.send\\s*\\(\\s*(?:err|error|e)\\.message\\b",
+  "bad": "return reply.code(500).send({ error: { code: 'INTERNAL', message: err.message } });",
+  "good": "request.log.error({ err }, 'unhandled');\nreturn reply.code(500).send({ error: { code: 'INTERNAL', message: 'internal error', correlation_id: request.id } });"
+}

package/packs/fastify/checks/no-regexp-from-input.json

@@ -0,0 +1,24 @@
+{
+  "id": "no-regexp-from-input",
+  "why": "new RegExp(input) is ReDoS and pattern injection. Escape with a helper, or anchor and length-cap the input before it becomes a pattern.",
+  "rule": ".claude/rules/credentials-and-input.md",
+  "concepts": [
+    "routes"
+  ],
+  "exclude": [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    ".claude/**",
+    "**/.claude/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "code": true,
+  "pattern": "\\bnew\\s+RegExp\\s*\\(\\s*(?!['\\\"`/])(?!escapeRegExp|escapeRegex|escapeRe)\\w",
+  "bad": "const re = new RegExp(query.q);",
+  "good": "const re = new RegExp(escapeRegExp(query.q));\nconst fixed = new RegExp('^[a-z]+$');"
+}