navori 0.7.0 → 0.7.2

package/dist/assets/core/core-assets/hooks/guard-destructive.sh

@@ -334,6 +334,60 @@ else
   skeleton="${cmd}${_nl}"
 fi
 
+# ─── Fast path: a command no rule below can possibly match ───────────────────
+#
+# WHY: this guard runs on EVERY Bash call, and in auto mode the host tells the
+# agent to work through the shell — so it is in front of reads, greps and edits
+# alike. Measured, it costs ~46 ms against a ~2 ms process floor: the other
+# ~44 ms is the `sed`/`grep` pipeline below, roughly forty forks. Over one
+# audited session that is 901 invocations and ~40 s of wall clock spent proving
+# that `cat file` is not `rm -rf /`. On 9,398 real commands from that session,
+# 80% contain none of the tokens below.
+#
+# WHY IT IS SOUND, which is the only part that matters in a security control:
+# every `block` in this file needs one of these literal substrings to survive
+# into the string its rule reads — `git` (rules 1-2, via `$git_cp`), `rm`
+# (rule 3), `:(` (rule 4), `/dev/` (rule 5), and `>`/`sed`/`tee` (rule 6, the
+# three write verbs it recognizes). No rule can fire without one.
+#
+# The probe is the command with quotes, backslashes and newlines REMOVED, which
+# is what makes the argument hold under the obfuscations the rules normalize
+# away: `r'm' -rf ~` becomes `rm -rf ~`, `\git` becomes `git`, and a `g\<NL>it`
+# split across a continuation is rejoined. Removal is the safe direction on
+# purpose — none of the tokens contains a quote, a backslash or a newline, so
+# stripping those can only CREATE matches, never destroy one. A false match
+# costs the full analysis; a false miss would be a hole, and cannot happen here.
+#
+# PLACEMENT is load-bearing too: this sits AFTER the three fail-closed size
+# limits (`CMD_MAX`, `LINE_MAX`, `HEREDOC_PROBE_MAX`) so a command too large to
+# inspect is still blocked, exactly as before. It skips the rule machinery, never
+# a refusal. And it reads `$cmd`, not `$skeleton`: the skeleton drops inert
+# heredoc bodies, so scanning it would narrow what the probe sees.
+#
+# FAST_MAX exists because `${var//pat/}` is NOT linear in bash: on a string past
+# ~64 KB with thousands of matches it goes superlinear hard — measured, 1024
+# lines of quoted `echo` strip instantly and 2048 lines had not finished after
+# nine minutes. An optimization that hangs the guard is a guard that hangs, so
+# the probe is only built for a command small enough for the cost to be free.
+# Above it, the full analysis runs exactly as it did before this block existed.
+# 4096 covers 98.5% of 1,089 real commands from the measured session (p50 370,
+# p90 1650) and sits sixteen times below the cliff.
+FAST_MAX=4096
+if [ "${#cmd}" -le "$FAST_MAX" ]; then
+  _fast=${cmd//\'/}
+  _fast=${_fast//\"/}
+  _fast=${_fast//\\/}
+  _fast=${_fast//"${_nl}"/}
+  case "$_fast" in
+    *git*|*rm*|*sed*|*tee*|*'/dev/'*|*'>'*|*':('*) ;;
+    *)
+      navori_audit_verdict="skip"
+      navori_audit_reason="no rule token in the command"
+      exit 0
+      ;;
+  esac
+fi
+
 # A `$(…)`/backtick substitution outside single quotes RUNS: `git commit -m
 # "$(rm -rf ~)"` is an invocation wearing a message's clothes. This check must
 # read the skeleton BEFORE the flag values are elided below — eliding first

package/dist/assets/core/core-assets/lib-skills/zod-validation.md

@@ -6,36 +6,44 @@ type: reference
 
 # Zod Validation — the canonical pattern
 
-One schema per resource (`<resource>.schema.ts`), validated by a generic middleware that replaces `req[target]` with the parsed and typed value. The DTO comes from `z.infer`.
+One schema per resource (`<resource>.schema.ts`), a generic validate middleware, and the DTO from `z.infer`.
 
 ## When to use this skill
 
-When creating a schema, adding validation to an endpoint, inferring a DTO, or touching input from body/query/params.
+When creating a schema, adding validation to an endpoint, inferring a DTO, or touching body/query/params input.
+
+**Check the installed major** (`package.json`): snippets are **Zod 4**, with the v3 form annotated inline where they differ.
 
 ## The pattern
 
-A single shared middleware (Express shown here) parses `req[target]` against the schema, and on failure throws `BadRequestError(\`${path}: ${first.message}\`)` with the first issue. On success, it reassigns `req[target] = parsed`. Schema and DTO:
+The middleware (Express here) parses `req[target]`, throws `BadRequestError` from the first issue, or reassigns `req[target] = parsed`:
 
 ```ts
-const objectId = z.string().regex(/^[a-f\d]{24}$/i, 'Invalid ObjectId');
-
 export const createResourceSchema = z.object({
-  owner: objectId,
-  resourceType: z.nativeEnum(ResourceTypeEnum),
+  owner: z.uuid(),                        // v3: z.string().uuid()
+  resourceType: z.enum(ResourceTypeEnum), // v3: z.nativeEnum(ResourceTypeEnum)
   page: z.coerce.number().int().positive().default(1)
 });
 export const updateResourceSchema = createResourceSchema.partial();
 export type CreateResourceDto = z.infer<typeof createResourceSchema>;
 ```
 
-In the route: `router.post('/', validate(createResourceSchema, 'body'), ...)`. In the controller the cast `req.body as CreateResourceDto` is safe because the middleware already parsed it.
+Route: `router.post('/', validate(createResourceSchema, 'body'), ...)`. The controller's `req.body as CreateResourceDto` cast is safe: already parsed.
+
+`safeParse` failure → readable 4xx (v4):
+
+```ts
+const parsed = schema.safeParse(req.body);
+if (!parsed.success) return res.status(400).json({ error: z.prettifyError(parsed.error) });
+```
+
+`z.prettifyError(e)` → readable string; `z.treeifyError(e)` → input-shaped object for per-field errors; `e.issues` → raw array (both majors). **v3 has neither:** `e.format()` / `e.flatten()`.
 
 ## Gotchas that bite
 
-- **A bare ObjectId** (`z.string()`) lets `"abc"` through; Mongoose throws a CastError 500 instead of a clean 400. Always use the `objectId` helper.
-- **Query strings are always strings.** Without `z.coerce`, `z.number()` rejects them. Use `z.coerce.number()` / `z.coerce.date()`. **Footgun:** `z.coerce.number()` uses `Number()`, so `""`/`" "`/`null` → `0` (an empty `?page=` passes as `0`). If it matters, set explicit bounds or `z.string().regex(...).transform(Number)`.
-- **Unknown keys are silently dropped:** `z.object({...})` *strips*, so a typo in the body (`{ ammount }`) is lost with no error. On mutation endpoints use `z.strictObject({...})` to catch it.
-- **Version:** this skill assumes Zod v3. In **v4**: `z.nativeEnum`→`z.enum`, `z.string().datetime()`→`z.iso.datetime()`, and `{ message }`→`{ error }` in the error options.
+- **A bare id** (`z.string()`) lets `"abc"` through and the layer below breaks on it — a driver cast error becomes a 500 instead of a clean 400. Validate the id's *shape*: `z.uuid()`, `z.cuid()`, `z.coerce.number().int()` (serial) or `.regex(...)`. *Mongo:* `z.string().regex(/^[a-f\d]{24}$/i, 'Invalid ObjectId')` — see the `mongoose` skill.
+- **Query strings are always strings.** Without `z.coerce`, `z.number()` rejects them. **Footgun:** `z.coerce.number()` uses `Number()`, so `""`/`" "`/`null` → `0` (an empty `?page=` passes as `0`); set explicit bounds or `z.string().regex(...).transform(Number)`.
+- **Unknown keys are silently dropped:** `z.object({...})` *strips*, so a typo in the body (`{ ammount }`) is lost with no error. On mutation endpoints use `z.strictObject({...})`.
 
 ## Hard rules
 
@@ -43,26 +51,29 @@ In the route: `router.post('/', validate(createResourceSchema, 'body'), ...)`. I
 2. The schema lives in `<resource>.schema.ts`, never in the routes.
 3. DTO always with `z.infer` — don't maintain two parallel types.
 4. No `z.any()`: it equals `any`, forbidden in new code.
-5. A single validator per endpoint — don't mix Joi + Zod (when migrating Joi→Zod, migrate the whole endpoint).
-6. Mongo ObjectId with the `objectId` helper; query/params with `z.coerce`.
+5. One validator per endpoint — no Joi + Zod mix; migrate the whole endpoint.
+6. Ids validated by shape, never a bare `z.string()`; query/params with `z.coerce`.
 
 ## Quick table
 
+`v4 · v3` where they differ.
+
 | Need to validate | Helper |
 |---|---|
-| ObjectId | `objectId` (regex `/^[a-f\d]{24}$/i`) |
+| Id | shape-specific, never `z.string()`: `z.uuid()` · `z.string().uuid()` |
 | Non-empty string | `z.string().trim().min(1)` |
 | Number from query | `z.coerce.number().int().positive()` |
-| Date | `z.coerce.date()` or `z.string().datetime()` |
-| TS enum / literal | `z.nativeEnum(MyEnum)` / `z.enum(['a','b'])` |
+| Date | `z.coerce.date()`, `z.iso.datetime()` · `z.string().datetime()` |
+| TS enum / literal | `z.enum(MyEnum)` · `z.nativeEnum(MyEnum)`; `z.enum(['a','b'])` |
 | Partial update | `createSchema.partial()` |
-| Cross-field validation | `.refine((d) => ..., { message, path })` |
+| Cross-field validation | `.refine((d) => ..., { error, path })` · `{ message, path }` |
+| Error → 4xx body | `z.prettifyError(e)` · `e.format()` |
 
 ## Before declaring done
 
-- The schema lives in `<resource>.schema.ts` and the DTO comes from `z.infer`.
-- The endpoint uses `validate(schema, target)`; no inline validation in the controller.
-- ObjectId fields with the `objectId` helper; query fields with `z.coerce`.
+- Schema in `<resource>.schema.ts`, DTO from `z.infer`, endpoint wired with `validate(schema, target)` — no inline validation in the controller.
+- Ids validated by shape, not a bare `z.string()`; query fields with `z.coerce`.
+- APIs match the installed major — no `z.nativeEnum` on v4, no `z.prettifyError` on v3.
 - `{{qualityGate.fast}}` green.
 
 <!-- navori:user-section -->

package/dist/assets/core/core-assets/presets/bun-keystone/skills/keystone-graphql.md

@@ -0,0 +1,56 @@
+---
+name: keystone-graphql
+description: Custom GraphQL in Keystone 6 — extendGraphqlSchema, the project-scoped gWithContext<Context>() builder, and the access guard every custom resolver must open with. Use when adding or touching a custom mutation, query or resolver.
+type: reference
+---
+
+# Keystone Custom GraphQL — extendGraphqlSchema
+
+## When to use this skill
+
+Before adding or changing a custom mutation/query, or when debugging a resolver that won't type-check. A custom resolver does **not** go through the list's `access`: the guard it doesn't write is a guard nobody writes.
+
+## The builder must carry the project `Context`
+
+Keystone 8 renamed `graphql` to `g` and changed how it's typed. Importing `g`/`graphql` straight from `@keystone-6/core` gives `GWithContext<KeystoneContext>` — bound to Keystone's **base** context, not the project's generated `Context`. Resolvers are typed against that generated `Context`, so a field built with the unparametrized builder fails to unify (`TS2322`/`TS2345`): the two contexts are structurally similar but nominally distinct types.
+
+Keystone's documented fix: **one project module builds `gWithContext<Context>()` once**, and everything imports `g` from there. Never import `graphql`/`g` from `@keystone-6/core` in project code.
+
+**One exception — `virtual()` fields on a list.** Keystone types their `field` as `VirtualFieldGraphQLField<BaseItem, KeystoneContext<BaseKeystoneTypeInfo>>`, against the base context, so the project-scoped `g` yields a type that does not unify with it (`TS2322`). Those import `g` from `@keystone-6/core` directly, with a comment saying why; everything under `extendGraphqlSchema` uses the shared builder.
+
+## The pattern: pure resolver + thin field
+
+```ts
+/** Accepts an open appeal. Only a moderator may resolve one. */
+export async function resolveAcceptAppeal(
+  args: { appealId: string },
+  context: Context, // the GENERATED Context, not KeystoneContext
+): Promise<AppealResult> {
+  requireModerator(context, "…"); // guard FIRST, before any data
+  // …
+}
+
+export const acceptAppeal = g.field({ // g from the project module
+  type: g.object<AppealResult>()({ name: "AcceptAppealPayload", fields: { /* … */ } }),
+  args: { appealId: g.arg({ type: g.nonNull(g.ID) }) },
+  resolve: (_root, { appealId }, context: Context) => resolveAcceptAppeal({ appealId }, context),
+});
+```
+
+Wire it with `extendGraphqlSchema: g.extend((base) => ({ mutation: { … }, query: { … } }))`; `base.object("Report")` reuses a list's generated type instead of redeclaring one.
+
+## Hard rules
+
+1. **Guard first.** Every custom mutation/query checks session/role before touching data — the list `access` never runs here, so skipping it is an access bypass. Shared guards live in one module (see `keystone-access`).
+2. **The resolver is a pure exported function**, separate from the `g.field` wrapping it: `(args, context) => payload`. Testable without booting GraphQL, and the unit under test (see `keystone-testing`).
+3. **`g` comes from the project builder**, never from `@keystone-6/core` — `virtual()` fields excepted.
+4. **Args are untrusted.** Validate them; never forward a raw `*CreateInput` into a write: the resolver runs through `context.sudo()`, which bypasses field-level access, so unfiltered `data` is mass-assignment. Whitelist what the client may supply.
+5. **`context.sudo().db` inside the resolver** (see `keystone-models`); errors surface bounded messages, never internals.
+
+## Before declaring the change "done"
+
+- `{{qualityGate.fast}}` green.
+- No `g`/`graphql` imported from `@keystone-6/core` outside the shared builder and `virtual()` fields.
+- Every new mutation/query calls its guard before the first read or write.
+- The resolver is exported and unit-tested with a mocked context.
+- No raw client input reaches a `sudo()` write unfiltered.

package/dist/assets/core/core-assets/presets/bun-keystone/skills/prisma-keystone.md

@@ -1,6 +1,6 @@
 ---
 name: prisma-keystone
-description: Prisma under Keystone 6 — autogenerated schema.prisma (don't edit by hand), migrations via the Prisma CLI, and context.prisma only in scripts. Use when changing the data shape or running migrations.
+description: Prisma under Keystone — generated schema.prisma (don't edit by hand), the Prisma 7 driver adapter and generated client, migrations via the Prisma CLI. Use when changing the data shape, wiring a DB connection or running migrations.
 type: reference
 ---
 
@@ -8,27 +8,35 @@ type: reference
 
 ## When to use this skill
 
-When adding/changing a field or a list (changes the DB shape), when running or reviewing migrations, or when writing a seed/backfill script. The classic mistake is editing `schema.prisma` or `schema.graphql` by hand — both are generated artifacts and your change is lost on the next generation.
+When changing the DB shape, running or reviewing migrations, opening a database connection, or writing a seed/backfill script.
 
 ## Base rule: the schema is derived, not source
 
 - **`schema.prisma` and `schema.graphql` are autogenerated by Keystone** from the lists. The source of truth is the `models/` files. **Never edit them by hand.**
-- To change the DB: edit the list (new field, type change, relation), regenerate and migrate. Keystone rewrites the schema.
-- Don't read the whole `schema.prisma` to "understand the types" — infer them from the list or search with `grep`. It's long and derived.
+- To change the DB: edit the list, regenerate and migrate — Keystone rewrites the schema.
+- Don't read all of `schema.prisma` to "understand the types": it's long and derived; `grep` it or read the list.
+
+## Prisma 7: generated client, driver adapter
+
+- **Import the client from the generator's `output`, never from `@prisma/client`.** The `generator client` block in `schema.prisma` declares the directory it writes to; that path is the module every import must use — read it, don't guess.
+- **`new PrismaClient()` with no options throws.** Prisma 7 dropped the Rust engine: the client needs a driver adapter (`PrismaPg` from `@prisma/adapter-pg` on Postgres). Every process that talks to the DB (Keystone via `prismaClientOptions`, workers, scripts) needs one: build it once in a shared module, not per entrypoint.
+- **Pool settings moved from the URL to the adapter.** `connection_limit`, `connect_timeout` and `pool_timeout` on `DATABASE_URL` were read by the engine; the `pg` adapter **ignores them silently**. They are pool options now (`max`, `connectionTimeoutMillis`). Set `connectionTimeoutMillis` explicitly: `pg` defaults it to 0 ("wait forever"), turning a database blip into a hung request nothing reclaims.
 
 ## Migrations (via the Prisma CLI)
 
 ```bash
-# Development: generates + applies a migration from the change in the lists
+# dev: generate + apply a migration
 prisma migrate dev --name <short-description>
 
-# Production / deploy: applies already-generated migrations
+# deploy: apply generated migrations
 prisma migrate deploy
 ```
 
-Run the Prisma CLI directly. The `keystone prisma ...` wrapper was **removed in `@keystone-6/core` v8** — its CLI now only accepts `dev`, `build`, `start`, `postinstall` and `telemetry`, so a leftover `keystone prisma migrate` fails with `unknown command`. The wrapper existed to pick up Keystone's database config; from Prisma 7 that config lives in `prisma.config.ts`, which the bare CLI loads on its own.
+Run the Prisma CLI directly: the `keystone prisma ...` wrapper was **removed in `@keystone-6/core` v8**, so a leftover `keystone prisma migrate` fails with `unknown command`. It existed to pick up Keystone's database config; from Prisma 7 that config lives in `prisma.config.ts`, loaded by the bare CLI.
+
+Read that file before assuming any CLI input: `migrations.path` says where migrations live (Prisma's `prisma/migrations` default is not a given), `datasource.shadowDatabaseUrl` replaces the `--shadow-database-url` flag `prisma migrate diff` lost, and its side-effect import of the env loader is what loads `.env` — Prisma 7 no longer does.
 
-Review the generated SQL before committing the migration: a destructive migration (dropping a column with data) needs a data plan, not just the schema change.
+Review generated SQL before committing: a destructive migration (dropping a column with data) needs a data plan.
 
 ## context.prisma — only in scripts
 
@@ -37,11 +45,13 @@ context.sudo().db.Model;  // app runtime (hooks/services) — see keystone-model
 context.prisma;           // ONLY seed/migration/backfill scripts — never at runtime
 ```
 
-`context.prisma` gives you the raw Prisma client (without Keystone's access or hooks). It's the right tool for a seed or a bulk backfill, and the wrong tool inside a hook or a resolver — there, always `context.sudo().db`.
+`context.prisma` is the raw client (no Keystone access control or hooks): right for a seed or bulk backfill, wrong in a hook or resolver — there, always `context.sudo().db`.
 
 ## Before declaring the change "done"
 
 - `{{qualityGate.fast}}` green.
-- Neither `schema.prisma` nor `schema.graphql` was edited by hand (they appear only as output of the regeneration).
-- Every new migration is committed alongside the list change that originates it.
+- Neither `schema.prisma` nor `schema.graphql` was edited by hand.
+- Every new migration is committed with the list change that originates it.
 - No `context.prisma` outside `scripts/`.
+- No import from `@prisma/client`: every client import resolves to the generator's `output`.
+- No pool setting as a `DATABASE_URL` query param — only the adapter reads those.

package/dist/assets/core/core-assets/presets/bun-keystone.json

@@ -36,6 +36,11 @@
         "id": "keystone-rest",
         "relPath": "presets/bun-keystone/skills/keystone-rest.md",
         "destRelPath": ".claude/skills/keystone-rest.md"
+      },
+      {
+        "id": "keystone-graphql",
+        "relPath": "presets/bun-keystone/skills/keystone-graphql.md",
+        "destRelPath": ".claude/skills/keystone-graphql.md"
       }
     ],
     "hooks": []