@jskit-ai/agent-docs 0.1.114 → 0.1.116

package/guide/agent/app-setup/a-more-interesting-shell.md

@@ -671,6 +671,23 @@ import {
 - whether the drawer is open right now
 - whether the drawer should open by default on load
 
+The closed presentation is adaptive and uses Vuetify's Material navigation
+components. On compact/mobile layouts the temporary drawer closes completely.
+On medium and expanded layouts it collapses to a navigation rail by default,
+so primary navigation remains visible. Opening it restores the full drawer.
+
+The app-owned `ShellLayout` can opt into a fully hidden wide drawer when the
+product has another discoverable navigation affordance:
+
+```vue
+<ShellLayout desktop-drawer-closed-mode="hidden">
+  <RouterView />
+</ShellLayout>
+```
+
+The default is `desktop-drawer-closed-mode="rail"`. Prefer that Material 3
+pattern; do not imitate a rail with custom CSS or a second menu registry.
+
 `useShellErrorPresentationStore()` exposes the current banner, snackbar, and dialog presentation state behind `ShellErrorHost`.
 
 The simplest direct store usage looks like this:

package/guide/agent/app-setup/initial-scaffolding.md

@@ -38,7 +38,18 @@ If you deliberately need the older bare scaffold, use `--minimal` or `--template
 npx @jskit-ai/create-app exampleapp --minimal --tenancy-mode none
 ```
 
-Minimal apps can still install the standard shell later with `npx jskit add package shell-web`, as long as the starter files it claims have not been edited first.
+Minimal apps can still install the standard shell later with
+`npx --no-install jskit add package shell-web`, as long as the starter files it
+claims have not been edited first. After the initial `npm install`, prefer
+`npx --no-install jskit` for every local JSKIT command so a missing local CLI
+fails clearly.
+
+When a minimal app's first feature is generated CRUD, do not pre-install the
+shell as a workaround. Add the database runtime, run `npm install`, create the
+live disposable table, run `crud-server-generator scaffold`, run
+`npm install` again, and then run `crud-ui-generator crud`. The server
+generator installs the shell/realtime dependency closure in the correct order.
+The complete Notes command lane is in [CRUD Generators](/guide/generators/crud-generators#fresh-minimal-notes-app-the-complete-command-order).
 
 If you already know you want a small non-workspace baseline right after the scaffold, this is the shortest reproducible path:
 
@@ -184,7 +195,7 @@ The most important parts look like this:
     "@tanstack/vue-query": "^5.101.0",
     "@jskit-ai/http-runtime": "0.x",
     "fastify": "^5.8.5",
-    "json-rest-schema": "^1.0.16",
+    "json-rest-schema": "^1.0.17",
     "pinia": "^3.0.4",
     "vue": "^3.5.38",
     "vue-router": "^5.1.0",
@@ -211,6 +222,8 @@ That matters because JSKIT maintenance policy changes over time. If the scaffold
 
 The Playwright scaffold follows the same rule. `playwright.config.mjs` delegates to `@jskit-ai/jskit-cli/test/playwright`, and the starter browser specs delegate their shared responsive checks to published JSKIT helpers. The generated files stay small while later JSKIT package updates can change local server startup, managed `PLAYWRIGHT_BASE_URL` handling, and `VIBE64_PLAYWRIGHT_STORAGE_STATE` support without copying that logic into each new app.
 
+The scaffold also configures `src/typed-router.d.ts` as generated output. It is intentionally absent from a fresh scaffold and ignored by Git; the Vue Router Vite plugin writes it during the first `npm run dev` or `npm run build` route scan.
+
 `jskit app verify` is worth noticing specifically. Linting, tests, and builds check your source code and runtime behavior. The JSKIT part of that flow runs `doctor`, which checks JSKIT-managed app state: installed package visibility, lock-file-backed managed files, and other JSKIT-specific health rules. It is there because a JSKIT app is not only code. It is also a descriptor-driven managed project.
 
 The starter scaffold also writes `.github/workflows/jskit-verify.yml`. JSKIT generates and owns that workflow as a projection of installed package `ci` contracts. The baseline runs checkout, Node 26 setup, `npm ci`, and `npm run verify`. Packages can add job environment values, service containers, and explicit `before-verify` steps without taking ownership of the whole YAML file. For example, the database runtime adds migrations before verification. Its MySQL driver adds a MariaDB service with synthetic CI-only credentials and `DB_CLIENT=mysql2`; its Postgres driver adds the equivalent Postgres service and `DB_CLIENT=pg`.

package/guide/agent/app-setup/working-with-the-jskit-cli.md

@@ -45,6 +45,20 @@ That lock file is the source of truth for installed JSKIT-managed package state.
 
 That is why commands such as `update`, `remove`, `position`, `migrations`, and `doctor` all care about `.jskit/lock.json`.
 
+### App-owned does not mean disposable
+
+A path recorded in `.jskit/lock.json` remains managed while its owning package
+is installed. “App-owned” means customizable, not disposable while the package
+remains installed. You may edit the file; you may not delete or rename it
+without changing the managed package contract.
+
+Never delete or rename a recorded managed path. Adapt generated infrastructure
+tests in place. If a starter product route is replaced, update the scaffold
+smoke test to exercise the new canonical route instead of deleting baseline
+browser coverage. In particular, preserve managed tests such as
+`tests/e2e/base-shell.spec.ts` and `tests/e2e/adaptive-shell.spec.ts`. Doctor
+must continue to flag a managed test that is missing.
+
 ## JSKIT-managed app maintenance scripts
 
 The scaffolded app also has a small set of `npm run` shortcuts that are really wrappers around JSKIT-owned maintenance behavior.

package/guide/agent/generators/crud-generators.md

@@ -31,6 +31,73 @@ It is meant to answer:
 
 Once that workflow is clear, continue with [Advanced CRUDs](/guide/generators/advanced-cruds) for the generated package anatomy, ownership model, and customization boundaries.
 
+## Fresh minimal Notes app: the complete command order
+
+The dependency install boundaries are part of the workflow. After the first
+install, use `npx --no-install jskit` so the command fails if the app-local CLI
+is unavailable instead of fetching a different copy.
+
+```bash
+npx @jskit-ai/create-app notes \
+  --target . \
+  --force \
+  --tenancy-mode none \
+  --minimal
+npm install
+
+npx --no-install jskit add package database-runtime-mysql
+npm install
+
+# Create and select a fresh disposable database, then create the live `notes` table.
+
+npx --no-install jskit generate crud-server-generator scaffold \
+  --namespace notes \
+  --surface home \
+  --ownership-filter public \
+  --access public \
+  --table-name notes
+npm install
+
+npx --no-install jskit generate crud-ui-generator crud notes \
+  --resource-file packages/notes/src/shared/noteResource.js \
+  --id-param noteId \
+  --display-fields title,body \
+  --parent-title contextual \
+  --navigation-role primary \
+  --delete-confirmation
+```
+
+The server generator resolves the complete package closure. `shell-web`
+establishes and owns `src/placement.js` before `realtime` contributes its
+placement, so do not pre-install the shell as a workaround.
+
+## Existing-app migration checklist
+
+JSKIT is still version 0, so this release uses a direct code migration rather
+than a legacy compatibility layer:
+
+1. Commit the app's current work, then run `npm run jskit:update`.
+2. If the app declares `json-rest-schema` directly, install
+   `json-rest-schema@^1.0.17`.
+3. Replace resource-bound JavaScript `Date` values with strings. `date` is
+   `YYYY-MM-DD`; `time` is offset-free `HH:MM[:SS[.fraction]]`; and `dateTime`
+   is RFC 3339 with seconds and a `Z` or numeric offset. Replace the removed
+   `timestamp` type with `epochMilliseconds` or `epochSeconds` only after
+   checking the existing numeric unit. Preserve `temporalPrecision`.
+4. For a standard generated view delete action, rerun the original
+   `crud-ui-generator crud` command with `--delete-confirmation`. Add `--force`
+   only when you deliberately want to replace unchanged generated page output.
+   For a customized view, preserve the customization and add the public
+   `CrudViewScreen` `actions` slot plus `useCrudDeleteAction()` integration
+   described below.
+5. Keep every managed path recorded in `.jskit/lock.json`. Adapt managed shell
+   and browser tests in place; never delete them because a starter route was
+   replaced.
+
+Generated generic CRUD repositories convert database temporal values at the
+resource boundary. Custom repositories still need to return strict temporal
+strings and write ISO/RFC 3339 strings explicitly.
+
 ## The two generator packages
 
 ### `crud-server-generator` `@jskit-ai/crud-server-generator` `(0.1.47)`
@@ -449,7 +516,8 @@ npx jskit generate crud-ui-generator crud \
   w/[workspaceSlug]/admin/contacts \
   --resource-file packages/contacts/src/shared/contactResource.js \
   --id-param contactId \
-  --display-fields fullName,email,phone
+  --display-fields fullName,email,phone \
+  --delete-confirmation
 ```
 
 That creates the baseline CRUD route tree:
@@ -465,6 +533,20 @@ The mirrored component root is intentional. The configured file router scans
 Vue files below `src/pages/`, so reusable Vue helpers must stay outside that
 directory or they become browser routes.
 
+`--delete-confirmation` is opt-in. When present, the generated view extends
+the public `CrudViewScreen` `actions` slot with a destructive Delete button and
+a Vuetify alert dialog. The public `useCrudDeleteAction()` composable resolves
+the current route id through the CRUD runtime, runs the shared resource's
+`DELETE` operation through `useCommand()`, disables duplicate submission,
+keeps a useful error on the record screen, invalidates the list query, and
+navigates to the generated list route after success. It supports custom
+`--id-param` names.
+
+The generator rejects this option when list or view is omitted, or when the
+shared resource has no `DELETE` operation. Without the flag, no delete control
+is generated. Do not substitute raw `fetch()` or import private `users-web`
+modules.
+
 Generated list, view, and lookup reads use the resource contract as their
 response authority. They return every field declared for output by default,
 including the target resource's declared output when a lookup relation is

package/guide/agent/index.md

@@ -40,3 +40,6 @@ It starts with a fast reproducible Quickstart, then steps back to the scaffold-f
 - Use `App Extras` once the base app structure is in place and you want optional runtime packages such as the Android shell, realtime, or assistant.
 - Jump into `Generators` if you already understand the runtime packages and want app-owned scaffolding workflows.
 - Inside `Generators`, read `CRUD Generators` before `Advanced CRUDs`: the first chapter teaches the workflow, and the second explains the generated anatomy and customization points.
+- Updating an existing app for strict temporal values or generated record
+  deletion? Go straight to the
+  [Existing-app migration checklist](/guide/generators/crud-generators#existing-app-migration-checklist).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/agent-docs",
-  "version": "0.1.114",
+  "version": "0.1.116",
   "description": "Distributed JSKIT agent references, prompts, guides, and generated reference maps.",
   "type": "module",
   "files": [

package/patterns/INDEX.md

@@ -18,17 +18,17 @@ How to use it:
   - `page-scaffolding.md`
 - child crud, nested crud, embedded list, subroute, separate page, parent/child layout
   - `child-cruds.md`
-- crud scaffold, crud server, crud ui, table creation, migrations, direct knex, weird-custom persistence, `crud-server-generator`, `crud-ui-generator`
+- crud scaffold, crud server, crud ui, table creation, migrations, direct knex, weird-custom persistence, fresh minimal app order, `crud-server-generator`, `crud-ui-generator`, `--delete-confirmation`
   - `crud-scaffolding.md`
 - CRUD links, record placeholders, `paths.page()`, `resolveViewUrl`, `resolveEditUrl`, `resolveParams`
   - `crud-links.md`
 - `definePage`, redirect, child redirect, settings landing, `redirectToChild`
   - `page-redirects.md`
-- live actions, checkbox, toggle, patch button, inline action, `useCommand()`
+- live actions, checkbox, toggle, patch button, delete confirmation, destructive action, inline action, `useCommand()`, `useCrudDeleteAction()`
   - `live-actions.md`
 - ajax, fetch, API call, request, endpoint, HTTP client, `useCrudListScreen()`, `useCrudViewScreen()`, `useCrudAddEditScreen()`, `useList()`, `useView()`, `useAddEdit()`, `useEndpointResource()`, `usersWebHttpClient`
   - `client-requests.md`
-- playwright, browser test, e2e, ui verification, authenticated ui test, test auth, dev login as, dev auth bypass
+- playwright, browser test, e2e, ui verification, managed test, `.jskit/lock.json`, authenticated ui test, test auth, dev login as, dev auth bypass
   - `ui-testing.md`
 - generated UI contract, design contract, navigation roles, density, placeholder copy, card shells, shared CRUD screens, row actions, synthetic rows, detail slots
   - `generated-ui-contract-tracking.md`
@@ -36,7 +36,7 @@ How to use it:
   - `filters.md`
 - `searchSchema`, `search: true`, `applyFilter`, server search, query validators, backend filters, internal JSON REST filters
   - `server-search.md`
-- `actualField`, `storage.writeSerializer`, `storage.virtual`, computed field, virtual field, projection, `createCrudResourceRuntime`, `remainingBatchWeight`, datetime write serialization
+- `actualField`, `storage.writeSerializer`, `storage.virtual`, computed field, virtual field, projection, `createCrudResourceRuntime`, `remainingBatchWeight`, datetime write serialization, temporalPrecision, json-rest-schema dates
   - `crud-repository-mapping.md`
 - row policy, permission filtering, visibility before pagination, recursive CTE, descendants, package cycle, `RowPolicyPlugin`
   - `row-policies.md`

package/patterns/crud-repository-mapping.md

@@ -113,6 +113,9 @@ If the resource module is server-only, a field may also declare `storage.queryPr
 What CRUD core does for you:
 - default select columns include only column-backed output fields
 - create/update write payloads serialize standard writable `date-time` fields centrally
+- database reads serialize `date`, `time`, and `dateTime` values to their
+  strict `json-rest-schema` string contracts before resource validation,
+  respecting `temporalPrecision`
 - create/update write payloads also apply any explicit field write serializers centrally
 - `list`, `findById`, `listByIds`, and `listByForeignIds` apply registered virtual projections automatically
 - search and parent-filter fallback derivation only use column-backed fields
@@ -131,3 +134,5 @@ Review checks:
 - computed fields use `storage: { virtual: true }`
 - repository runtime registers matching `virtualFields`, or the JSON REST provider registers matching `queryFields`
 - no per-method projection duplication when generic CRUD reads already cover the field
+- no JavaScript `Date` object crosses a strict resource validation boundary;
+  custom repositories return ISO/RFC 3339 strings explicitly

package/patterns/crud-scaffolding.md

@@ -14,6 +14,26 @@ Check first:
 - `jskit show crud-server-generator --details`
 - whether the request is server-only CRUD or server-plus-UI CRUD
 
+## Fresh minimal-app order
+
+After `create-app`, run `npm install` before invoking the local CLI, and then
+use `npx --no-install jskit` so a missing local CLI fails clearly. For a fresh
+minimal CRUD app, the complete order is:
+
+1. create the app
+2. `npm install`
+3. add the database runtime
+4. `npm install`
+5. create the live table in a fresh disposable development database
+6. run `crud-server-generator scaffold`
+7. `npm install`
+8. run `crud-ui-generator crud`
+
+The server generator resolves its complete package dependency closure. In
+particular, `shell-web` owns and establishes `src/placement.js` before
+`realtime` appends its placement. Do not pre-install `shell-web` as a
+workaround.
+
 ## Non-negotiable database contract
 
 Before database, schema, CRUD, repository, or persistence work, read this
@@ -75,6 +95,29 @@ Rules:
 - Bulk actions should be declared in the generated page-local `listBulkActions.js`. The generated list owns selection state, keeps selection controls hidden until actions exist, and exposes selected ids/records to action handlers.
 - Structured filters should use shared filter definitions and collapse to compact filter controls/sheets when they outgrow simple search. Do not stack dense desktop filter bars on phone widths.
 - Use `--navigation-role` for CRUD list placement intent. Main resources can stay `primary`; nested/detail/workflow CRUD routes should usually be `secondary`, `workflow`, or `none`.
+- Add `--delete-confirmation` when the generated view needs the standard
+  destructive record action. The flag requires list and view pages and a
+  resource with a `DELETE` operation; it uses the public view-screen action
+  slot and command composable rather than generated raw request code.
+
+## Temporal values at resource boundaries
+
+`json-rest-schema` 1.0.17 accepts strict string temporal values. Resource
+validators no longer coerce JavaScript `Date` objects:
+
+- `date` is `YYYY-MM-DD`
+- `time` is offset-free `HH:MM[:SS[.fraction]]`
+- `dateTime` is RFC 3339 with seconds and `Z` or a numeric offset
+
+The removed `timestamp` type must become `epochMilliseconds` or
+`epochSeconds` after checking the stored unit. Preserve the field's
+`temporalPrecision`; do not truncate meaningful fractional seconds.
+
+Generated generic CRUD repositories serialize database temporal outputs
+before resource validation. App-owned/custom repositories must return strict
+strings and must write ISO/RFC 3339 strings rather than passing `Date` objects.
+This is a version-0 breaking contract: update application code instead of
+adding a legacy temporal parser.
 
 ## Baseline generation versus later schema evolution
 

package/patterns/generated-ui-contract-tracking.md

@@ -52,7 +52,7 @@ Generated JSKIT apps should feel like real adaptive apps by default, not framewo
 - Do not remove intentional cards from specialist UI components just to satisfy a broad scan.
 - Keep generated files deterministic and update catalog/agent-doc outputs when descriptors or exported symbols change.
 - Kernel shared UI contract must stay surface-id agnostic. Concrete mappings like admin/console to operator profile belong in generators or package templates.
-- Item 3 is complete for current generated surfaces: page, CRUD, shell, and starter outputs require compact/medium/expanded coverage, horizontal overflow checks, generated screen checks, and 48px tap target checks. Calendar/grid/bottom-sheet specialist generators remain future scope until those generators exist.
+- Item 3 is complete for current generated surfaces: page, CRUD, shell, and starter outputs require compact/medium/expanded coverage, horizontal overflow checks, generated screen checks, and compact generated-screen 48px tap target checks. Calendar/grid/bottom-sheet specialist generators remain future scope until those generators exist.
 - Item 5 is complete for current generators: `primary`, `secondary`, `utility`, `detail`, `workflow`, and `none` are centralized in the generated UI contract, generators consume that contract, and `utility` resolves to seeded `shell.global-actions` topology.
 - Item 6 is complete for the default shell: compact app bars use compact density and bounded top-left/top-right regions, while primary navigation remains in semantic bottom navigation instead of app-bar chrome.
 - CRUD filters are client-side by default: generated list pages create a page-local `listFilters.js` and pass it into `useCrudListScreen(...)`; the shared list screen wires `filterRuntime.queryParams` into the list request and renders `CrudListFilterSurface`. When server filtering is needed, promote the definitions into a shared package module and use `createCrudListFilterContract(...)` so route/action validators, JSON REST search schema, and repository query normalization stay derived from the same definition.

package/patterns/live-actions.md

@@ -12,6 +12,25 @@ Rules:
 - Prefer `useCommand()` for live actions.
 - Prefer form runtimes such as `useCrudAddEdit()` or `useAddEdit()` for real forms.
 - Prefer `useCrudList()` and `useCrudView()` for routed CRUD loading and URL resolution.
+- For ordinary routed CRUD record deletion, generate the supported lane instead
+  of rebuilding it page by page:
+
+  ```bash
+  npx --no-install jskit generate crud-ui-generator crud notes \
+    --resource-file packages/notes/src/shared/noteResource.js \
+    --id-param noteId \
+    --display-fields title,body \
+    --parent-title contextual \
+    --navigation-role primary \
+    --delete-confirmation
+  ```
+
+  `--delete-confirmation` requires generated list and view pages plus a shared
+  resource with a `DELETE` operation. It extends the view through the public
+  `CrudViewScreen` `actions` slot and `useCrudDeleteAction()`: Vuetify owns the
+  alert dialog, `useCommand()` owns the request state, the shared resource owns
+  the DELETE contract, and successful deletion invalidates the list query and
+  navigates to the generated list route.
 
 Good live-action pattern:
 
@@ -30,4 +49,6 @@ Examples:
 Avoid:
 
 - manually hand-rolling fetch logic for a standard live action when `useCommand()` fits
+- inspecting private `users-web` internals or creating a page-local transport
+  for generated record deletion
 - pushing derived write rules into the client just because the action is small

package/patterns/ui-testing.md

@@ -11,7 +11,7 @@ Rules:
 
 - Any chunk that adds or changes user-facing UI must include a Playwright flow that exercises the changed behavior before the chunk is done.
 - Generator or package template UI changes must be checked at compact phone, tablet-ish medium, and expanded desktop widths.
-- For generated UI, check horizontal overflow, clipped or invisible text, duplicate navigation, broken route placement, and tap targets under 48 px.
+- For generated UI, check horizontal overflow, clipped or invisible text, duplicate navigation, and broken route placement at every standard viewport. On compact screens, also check generated-screen tap targets under 48 px; medium and expanded layouts may use their documented denser controls.
 - Apps with `shell-web` installed should start from `tests/e2e/adaptive-shell.spec.ts` and extend it with feature-specific assertions.
 - Generated `playwright.config.mjs` delegates to `@jskit-ai/jskit-cli/test/playwright`. Do not copy base-URL, web-server, or storage-state logic into app tests.
 - Use relative paths such as `page.goto("/home")`. The shared config owns the browser base URL.
@@ -19,6 +19,18 @@ Rules:
 - Vibe64 supplies an authenticated context through `VIBE64_PLAYWRIGHT_STORAGE_STATE`. Treat that file as a temporary secret: do not commit it, print it, or retain it after the run.
 - Do not install a browser when the environment provides a managed browser runner.
 
+## Preserve managed baseline tests
+
+“App-owned” means customizable, not disposable while the package remains
+installed. Never delete or rename a test path recorded in `.jskit/lock.json`.
+Generated and managed infrastructure tests must be adapted in place.
+
+When the starter product route is replaced, update the scaffold smoke test to
+visit and assert the new canonical route. Do not delete baseline browser
+coverage such as `tests/e2e/base-shell.spec.ts` or
+`tests/e2e/adaptive-shell.spec.ts`. JSKIT Doctor must continue to flag a
+managed test that is missing.
+
 ## Direct local authentication
 
 Use the development-only dev auth bypass when Playwright is talking directly to an app running on localhost.

package/reference/autogen/packages/crud-core.md

@@ -223,7 +223,7 @@ Exports
 - `requireCrudTableName(tableName, { context = "crudRepository" } = {})`
 - `deriveRepositoryMappingFromResource(resource = {}, { context = "crudRepository" } = {})`
 - `applyCrudListQueryFilters(query, { idColumn = "id", cursor = "", applyCursor = true, q = "", searchColumns = [], parentFilters = {}, parentFilterColumns = {} } = {})`
-- `mapRecordRow(row, fieldKeys = [], overrides = {}, { recordIdKeys = [] } = {})`
+- `mapRecordRow(row, fieldKeys = [], overrides = {}, { recordIdKeys = [], serializerByKey = {} } = {})`
 - `buildWritePayload(sourcePayload = {}, fieldKeys = [], overrides = {}, { serializerByKey = {} } = {})`
 - `resolveColumnName(fieldKey, overrides = {})`
 - `resolveCrudIdColumn(idColumn, { fallback = "id" } = {})`

package/reference/autogen/packages/crud-ui-generator.md

@@ -33,6 +33,7 @@ Local functions
 - `parseOperationsOption(options)`
 - `parseDisplayFieldsOption(options)`
 - `parseParentTitleOption(options)`
+- `resolveBooleanFlagOption(options = {}, optionName = "")`
 - `shouldCreateNavigationLink(options = {}, inferenceContext = {})`
 - `resolveNavigationRoleLinkPlacement(options = {}, inferenceContext = {})`
 - `validateDisplayFieldsForOperation(selectedFieldKeys, fields, operationName)`
@@ -60,6 +61,9 @@ Local functions
 - `resolveCrudRelativePath(namespace = "")`
 - `buildListParentTitleImportLine(parentTitleMode = "contextual")`
 - `buildListHeadingTitleSetup({ parentTitleMode = "contextual", resourceNamespace = "", routeTitle = "Records" } = {})`
+- `buildViewDeleteActionSlot({ resourceNamespace = "resource", resourceSingularTitle = "Record" } = {})`
+- `buildViewDeleteDialog({ resourceNamespace = "resource", resourceSingularTitle = "Record" } = {})`
+- `buildViewDeleteSetup({ resourceNamespace = "resource" } = {})`
 
 ### `src/server/resourceSupport.js`
 Exports
@@ -95,6 +99,7 @@ Local functions
 - `resolveSchemaReference(ref = "", rootSchema = {}, { context = "ui-generator", contextLabel = "schema" } = {})`
 - `resolveObjectSchema(schema = {}, contextLabel, { context = "ui-generator", rootSchema = schema } = {})`
 - `resolveJsonRestCastType(schema = {})`
+- `resolveTemporalPrecision(...schemas)`
 - `resolveSchemaType(schema)`
 - `toFieldLabel(key)`
 - `isSupportedSelectOptionValue(value)`
@@ -108,6 +113,7 @@ Local functions
 - `toLookupRelation(fieldContractMap = {}, fieldKey = "", { lookupContainerKey = "lookups" } = {})`
 - `resolveFormInputType(fieldType, fieldFormat)`
 - `resolveFormFieldComponent(fieldType, relation = null)`
+- `resolveTemporalInputStep(field = {})`
 - `buildDefaultNullableBooleanOptions()`
 - `toPositiveInteger(value)`
 - `toAccessorExpression(baseName, fieldKey)`

package/reference/autogen/packages/database-runtime.md

@@ -53,9 +53,18 @@ Exports
 - `toInsertDateTime(dateLike, fallback = new Date())`
 - `toNullableDateTime(value)`
 - `toDatabaseDateTimeUtc(value)`
+- `toJsonDate(value)`
+- `toJsonTime(value, { temporalPrecision } = {})`
+- `toJsonDateTime(value, { temporalPrecision } = {})`
 Local functions
 - `toDateOrThrow(value)`
 - `pad(value, size = 2)`
+- `requireValidDateParts(year, month, day)`
+- `requireValidTimeParts(hours, minutes, seconds = 0)`
+- `parseDateParts(value)`
+- `normalizeTemporalPrecision(value)`
+- `formatFraction(milliseconds, temporalPrecision)`
+- `requireAllowedFraction(fraction, temporalPrecision)`
 
 ### `src/shared/dialect.js`
 Exports
@@ -84,6 +93,9 @@ Exports
 - `toInsertDateTime`
 - `toNullableDateTime`
 - `toDatabaseDateTimeUtc`
+- `toJsonDate`
+- `toJsonTime`
+- `toJsonDateTime`
 - `normalizeDialect`
 - `detectDialectFromClient`
 - `normalizeText`

package/reference/autogen/packages/json-rest-api-core.md

@@ -41,9 +41,10 @@ Local functions
 - `cloneJsonRestResourceValue(value, { writeSerializers = {} } = {})`
 - `resolveCanonicalCalendarDate(value)`
 - `serializeJsonRestCalendarDate(value)`
+- `resolveCanonicalDateTime(value)`
 - `applyJsonRestCalendarDateWriteSerializers(scopeOptions = {})`
-- `normalizeJsonRestCalendarDateEntry(entry = null, scopes = {})`
-- `normalizeJsonRestCalendarDateDocument(document = null, scopes = {})`
+- `normalizeJsonRestTemporalEntry(entry = null, scopes = {})`
+- `normalizeJsonRestTemporalDocument(document = null, scopes = {})`
 - `normalizeScopeValue(value)`
 - `normalizeJsonRestText(value, { fallback = "" } = {})`
 - `normalizeJsonRestFilterValue(value)`

package/reference/autogen/packages/shell-web.md

@@ -66,6 +66,7 @@ Exports
 - None
 Local functions
 - `handlePullPointerDown(event)`
+- `handleDrawerVisibilityChange(open)`
 - `handlePullPointerMove(event)`
 - `handlePullPointerEnd(event)`
 - `handlePullPointerCancel(event)`
@@ -404,6 +405,13 @@ Local functions
 Exports
 - `useShellLayoutStore`
 
+### `src/client/support/drawerPresentation.js`
+Exports
+- `DESKTOP_DRAWER_CLOSED_MODES`
+- `normalizeDesktopDrawerClosedMode(value = "rail")`
+- `resolveShellDrawerPresentation({ compact = false, open = false, desktopClosedMode = "rail" } = {})`
+- `resolveShellDrawerToggleLabel({ compact = false, open = false } = {})`
+
 ### `src/client/support/menuLinkTarget.js`
 Exports
 - `normalizeMenuLinkPathname(pathname = "")`

package/reference/autogen/packages/users-core.md

@@ -124,15 +124,12 @@ Exports
 
 ### `src/server/common/repositories/repositoryUtils.js`
 Exports
-- `toNullableDateTime`
 - `toIsoString`
 - `isDuplicateEntryError`
 - `normalizeText`
 - `normalizeLowerText`
 - `normalizeRecordId`
 - `normalizeDbRecordId`
-- `nowDb()`
-- `toNullableIso(value)`
 - `uniqueSorted(values)`
 - `parseJson(value, fallback = {})`
 - `toDbJson(value, fallback = {})`

package/reference/autogen/packages/users-web.md

@@ -209,7 +209,8 @@ Local functions
 - `toTimeInputValue(value)`
 - `toDateTimeLocalInputValue(value)`
 - `toDateInputValue(value)`
-- `toIsoUtcDateTimeValue(value)`
+- `applyDateTimePrecision(isoValue, temporalPrecision)`
+- `toIsoUtcDateTimeValue(value, temporalPrecision)`
 - `resolveFormFieldInitialValue(field = {})`
 - `shouldSerializeClearedFieldAsNull(field = {})`
 
@@ -488,6 +489,15 @@ Exports
 Local functions
 - `normalizeProvidedScreen(screen = null)`
 
+### `src/client/composables/useCrudDeleteAction.js`
+Exports
+- `requireCrudDeleteOperation(resource = null)`
+- `resolveDeleteApiSuffix(screen, apiUrlTemplate = "")`
+- `useCrudDeleteAction({ screen = null, resource = null, resourceNamespace = "", apiUrlTemplate = "", access = "auto", client = null, router: routerOverride = null, fallbackDeleteError = "Unable to delete record." } = {})`
+Local functions
+- `requireCrudViewScreen(screen = null)`
+- `resolveListLocation(screen)`
+
 ### `src/client/composables/useCrudListBulkActions.js`
 Exports
 - `useCrudListBulkActions(actions = [], { resolveRecordId = null, resolveContext = null } = {})`
@@ -616,6 +626,7 @@ Exports
 - `CrudViewScreen`
 - `normalizeCrudApiAccess`
 - `resolveCrudHttpClient`
+- `useCrudDeleteAction`
 - `clientProviders`
 
 ### `src/client/lib/bootstrap.js`

package/reference/autogen/packages/workspaces-core.md

@@ -38,15 +38,12 @@ Exports
 
 ### `src/server/common/repositories/repositoryUtils.js`
 Exports
-- `toNullableDateTime`
 - `toIsoString`
 - `isDuplicateEntryError`
 - `normalizeText`
 - `normalizeLowerText`
 - `normalizeRecordId`
 - `normalizeDbRecordId`
-- `nowDb()`
-- `toNullableIso(value)`
 - `uniqueSorted(values)`
 - `parseJson(value, fallback = {})`
 - `toDbJson(value, fallback = {})`

package/skills/jskit/SKILL.md

@@ -1,13 +1,12 @@
 ---
 name: jskit
-description: Build, extend, troubleshoot, review, deslop, and verify JSKIT applications using the JSKIT CLI, runtime packages, generators, surfaces, placements, and managed-app conventions. Use for JSKIT scaffolding, pages, routes, UI, authentication, databases, CRUDs, users, workspaces, console features, migrations, package changes, upgrades, or pre-sign-off review.
+description: Build, extend, troubleshoot, review, deslop, and verify JSKIT apps using its CLI, packages, generators, surfaces, placements, CRUDs, managed files, and verification conventions.
 ---
 
 # JSKIT
 
-Use JSKIT's native CLI, generators, installed packages, and app-local
-contracts. This skill explains the technology; the request and application
-files define the product.
+Use JSKIT's CLI, generators, packages, and app-local contracts. The request
+and app files define the product.
 
 ## Exact caller lanes
 
@@ -24,9 +23,7 @@ Discover only a missing fact or exact-command failure, then resume the lane.
 1. Read the request and nearest `AGENTS.md`.
 2. Inspect `package.json`, `.jskit/lock.json`, the existing tree, and the
    current diff when reviewing changes.
-3. Read `.jskit/APP_BLUEPRINT.md` when present for durable product and
-   architecture decisions. Do not invent or expand product requirements from
-   this skill.
+3. Read `.jskit/APP_BLUEPRINT.md` when present; do not invent requirements.
 4. Load only the task-relevant direct reference:
    - For creation, package selection, CLI use, or generators, read
      [application operations](references/app-operations.md).
@@ -36,73 +33,43 @@ Discover only a missing fact or exact-command failure, then resume the lane.
      [UI operations](references/ui-operations.md).
 
 Those files are the complete operational references required by this skill.
-Do not depend on sibling package documentation being present. Do not load
-irrelevant references.
+Do not depend on sibling docs. Do not load irrelevant references.
 
 Do not invent missing tenancy, authentication, database, surface, ownership,
 or permission decisions when they would materially change the application.
 
 ## Discovery fallback
 
-- For a missing fact, use only the narrowest applicable JSKIT CLI query.
-- Prefer an existing JSKIT package, generator, placement, or high-level
-  composable over hand-wired local infrastructure.
-- Treat `.jskit/lock.json` and JSKIT-owned projections as managed state. Do not
-  hand-edit the lock or bypass managed-file lifecycle checks.
+Use the narrowest CLI query for a missing fact. Prefer existing packages,
+generators, placements, and high-level composables. Never hand-edit
+`.jskit/lock.json` or bypass managed-file lifecycle checks.
 
 ## Implement a change
 
-1. Use the caller-selected seam, or discover only a genuinely missing seam.
-2. Read the matching local reference above.
-3. Implement the smallest complete vertical slice at documented app-owned
-   seams.
-4. Install dependencies and run migrations only when the selected operation
-   requires them.
-5. For schema work, use only a fresh disposable development database; never
-   alter production, legacy, historical, or otherwise valuable data.
-
-For user-facing work, respect the selected surface and semantic placements,
-handle compact layouts and loading, empty, error, permission, and ownership
-states, and verify meaningful behavior in the browser.
+Read the matching reference and implement the smallest complete slice at
+documented seams. Install dependencies/migrate only when required. Use only a
+fresh disposable development database for schema work—never valuable data.
+For UI, respect surface/placements, compact layout, all operational states,
+permissions/ownership, and browser verification.
 
 ## Caller-owned verification
 
-When a calling orchestrator explicitly owns final tests, migrations, server
-lifecycle, browser checks, and sign-off, honor that division of work. Stay
-within its wall-time and action limits, implement the requested slice, return
-the requested manifest or summary, and stop. Do not start a dev server,
+When a caller owns tests, migrations, server lifecycle, browser checks, or
+sign-off, honor that division and its limits. Do not start a dev server,
 browser, Playwright, broad verifier, migration rebuild, or exploratory review
-unless that caller asks for it in the current task.
+unless requested in the current task.
 
 ## Review or deslop
 
-Review the requested chunk or whole changeset. If the request is review-only,
-report findings without editing.
-
-Check for:
-
-- Duplicated helpers, dead code, placeholders, accidental abstractions, and
-  incomplete states.
-- Missed JSKIT packages, generators, high-level composables, placements, or
-  runtime seams.
-- Invalid surface, route, ownership, permission, migration, or managed-file
-  choices.
-- Weak Material Design or Vuetify hierarchy, responsiveness, actions, and
-  state handling.
-- Verification proportional to scope, including Playwright for meaningful
-  user-facing flows.
-
-Present findings first, ordered by severity, with file references. Say
-explicitly when there are no findings.
+For review-only work, report without editing. Check duplicated/dead/wrong code,
+accidental abstraction, incomplete states, missed high-level JSKIT seams,
+invalid routing/ownership/permission/migration/managed-file choices, weak
+Vuetify/Material behavior, and proportional verification. Put findings first
+by severity with file references; state when none exist.
 
 ## Verify
 
-- Run focused tests for the changed slice and broad regression checks for a
-  whole changeset.
-- Run `npx jskit doctor` when managed state changed.
-- Run `npm run verify` before sign-off.
-- Rebuild migrations from zero against a fresh disposable database when
-  schema or persistence changed.
-- Run the relevant Playwright flow when user-facing behavior changed.
-- Report files reviewed or changed, commands run, and anything still
-  unverified.
+Run focused tests for a slice and broad checks for a whole changeset. Run
+Doctor for managed state, `npm run verify` before sign-off, rebuild changed
+persistence from zero in a disposable database, and use Playwright for UI.
+Report files, commands, and anything unverified.

package/skills/jskit/references/app-operations.md

@@ -1,11 +1,10 @@
 # Application operations
 
-Read this reference for application creation, CLI discovery, package changes,
-and generator selection.
+Read this for app creation, CLI discovery, packages, and generators.
 
 ## Create an application
 
-Confirm the application name and tenancy mode, then run:
+Confirm the name and tenancy mode:
 
 ```bash
 npx @jskit-ai/create-app <app-name> --tenancy-mode <tenancy-mode>
@@ -13,29 +12,56 @@ cd <app-name>
 npm install
 ```
 
-Generated applications require Node.js 26. Use `--target . --force` only to
-promote a known JSKIT `ai-seed` directory, never to overwrite an arbitrary
-application. Use `--minimal` only for a deliberately bare package-development
-or unusual integration baseline. After creation, follow the generated
-`AGENTS.md`.
+Generated apps require Node.js 26. Use `--target . --force` only to promote a
+known JSKIT `ai-seed`, never to overwrite an arbitrary app. `--minimal` is for
+deliberately bare package-development or unusual integrations. Follow the
+generated `AGENTS.md`.
 
-Do not add authentication, users, workspaces, console, example routes, sample
-records, or another database adapter unless the request requires them.
+After the first install, use `npx --no-install jskit ...`; a missing local CLI
+must fail instead of silently fetching another version. Do not add auth, users,
+workspaces, console, sample data, or another database adapter unless requested.
+
+## Fresh minimal database CRUD order
+
+Use this order exactly: create-app, install, add the database runtime, install,
+create the live table in a fresh disposable development database, generate the
+server CRUD, install, then generate the UI.
+
+```bash
+npx @jskit-ai/create-app notes \
+  --target . --force --tenancy-mode none --minimal
+npm install
+npx --no-install jskit add package database-runtime-mysql
+npm install
+# Create/select a fresh disposable database and create its live `notes` table.
+npx --no-install jskit generate crud-server-generator scaffold \
+  --namespace notes \
+  --surface home \
+  --ownership-filter public \
+  --access public \
+  --table-name notes
+npm install
+npx --no-install jskit generate crud-ui-generator crud notes \
+  --resource-file packages/notes/src/shared/noteResource.js \
+  --id-param noteId \
+  --display-fields title,body \
+  --parent-title contextual \
+  --navigation-role primary \
+  --delete-confirmation
+```
+
+The server generator owns its dependency closure. Do not pre-install
+`shell-web` as a placement workaround.
 
 ## Select and apply technology
 
-- Inspect available capabilities with `npx jskit list` and inspect a specific
-  entry with `npx jskit show <id> --details`.
-- Install reusable runtime capability with `npx jskit add package <id>`.
-- Inspect a bundle before installing it with `npx jskit add bundle <id>`.
-- Run tooling packages with
-  `npx jskit generate <generator> <action> ...`; do not install generators as
-  runtime packages.
-- Let `jskit` own JSKIT application mutations, use `npm install` for dependency
-  installation, and use `npm run db:migrate` for database migrations.
-- Review generated files and continue only at documented app-owned seams.
-
-Packages own reusable framework behavior. Generators create application-owned
-pages, components, placements, migrations, and support files. Prefer the
-narrowest installed package or generator that implements the requested
-vertical slice; do not build a parallel local framework around it.
+- Discover with `npx --no-install jskit list` and
+  `npx --no-install jskit show <id> --details`.
+- Install runtime capability with `npx --no-install jskit add package <id>`;
+  inspect a bundle before adding it.
+- Run tooling with `npx --no-install jskit generate <generator> <action> ...`;
+  do not install generators as runtime packages.
+- JSKIT owns app mutations, npm owns dependency installation, and
+  `npm run db:migrate` owns database migration execution.
+- Continue only at documented app-owned seams. Prefer the narrowest existing
+  package or generator over a parallel local framework.

package/skills/jskit/references/crud-operations.md

@@ -1,47 +1,36 @@
 # CRUD operations
 
-Read this reference completely before database, schema, CRUD, repository, or
-persistence work.
+Read this completely before database, schema, CRUD, repository, or persistence
+work.
 
 ## Establish the contract
 
-Determine the selected database adapter, surface, access rule, and ownership
-model from the request and app authority. Inspect only a generator whose exact
-lane or option values are missing, or whose supplied command failed:
+Take the database adapter, surface, access, and ownership from the request and
+app authority. Inspect only a generator whose exact lane or option values are
+missing, or whose supplied command failed:
 
 ```bash
-npx jskit show crud-server-generator --details
-npx jskit show crud-ui-generator --details
+npx --no-install jskit show crud-server-generator --details
+npx --no-install jskit show crud-ui-generator --details
 ```
 
 Never run these merely to reconfirm caller-supplied facts.
 
-For normal app-owned CRUD tables:
-
-- Use one non-null integer primary key, normally
-  `id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY`.
-- Make every foreign key single-column and target the referenced table's
-  single-column primary key. Use multi-column unique indexes only for business
-  uniqueness, never as relationship targets.
-- Use only direct `workspace_id` and/or `user_id` columns for generated JSKIT
-  ownership and choose the ownership filter matching those columns exactly.
-- Treat names such as `recipient_user_id`, `created_by_user_id`, and
-  `assignee_user_id` as domain relationships, not ownership aliases.
-- Express tenant-safe relationships as direct ownership plus a normal
-  `parent_id -> parent.id` relation. Test both allowed and cross-workspace
-  cases.
-
-Stop before generation if the schema uses composite relationship keys or if
-the ownership filter and reserved ownership columns disagree.
+Normal app-owned CRUD tables use one non-null integer primary key. Every
+foreign key is single-column and targets that key; multi-column unique indexes
+are business constraints, never relationship targets. Only direct
+`workspace_id` and `user_id` columns are generated ownership. Names such as
+`recipient_user_id` are domain relationships. Match the ownership filter to
+the reserved columns exactly, and test allowed plus cross-workspace cases.
+Stop before generation when these contracts disagree.
 
 ## Conventional one-table CRUD
 
-In a fresh disposable development database, create the validated table first.
-The server generator reads its live shape. Scaffold the server contract before
-the UI:
+Create the validated table first in a fresh disposable development database;
+the server generator reads its live shape:
 
 ```bash
-npx jskit generate crud-server-generator scaffold \
+npx --no-install jskit generate crud-server-generator scaffold \
   --namespace <resource> \
   --surface <surface> \
   --ownership-filter <public|user|workspace|workspace_user> \
@@ -49,63 +38,82 @@ npx jskit generate crud-server-generator scaffold \
   --table-name <table>
 ```
 
-Use `--access public` only with a non-workspace surface and public ownership;
-omit both role-grant flags. For workspace-required CRUDs, choose exactly one
-of `--grant-role <role>` or `--no-role-grant`. Never invent a role to satisfy
-the generator. Use `--internal` when the entity needs the generated
-repository/service/resource/migration ownership chain but no public HTTP CRUD
-routes.
+Use public access only on a non-workspace surface with public ownership. A
+workspace CRUD chooses exactly one of `--grant-role <role>` or
+`--no-role-grant`; never invent a role. `--internal` keeps the generated
+repository/service/resource ownership chain but suppresses public HTTP routes.
 
-Run `npm install`, then scaffold the UI from the generated shared resource:
+Run `npm install`, then generate UI from the exact shared resource:
 
 ```bash
-npx jskit generate crud-ui-generator crud \
+npx --no-install jskit generate crud-ui-generator crud \
   <pages-root>/<plural-route> \
   --resource-file packages/<namespace>/src/shared/<singular>Resource.js \
   --parent-title contextual
 ```
 
 The target is relative to `src/pages/`, starts with the selected surface's
-nonempty configured `pagesRoot`, and has no leading slash (for example
-`home/books`). For a surface deliberately configured with an empty root, use
-only the plural route (for example `books`). Use the exact singular resource
-filename emitted by the server generator; do not guess it.
+nonempty configured `pagesRoot` (for example `home/books`), and has no leading
+slash. For a surface deliberately configured with an empty root, use
+only the plural route. Use the exact singular resource filename emitted by the server generator; do not guess it.
+
+That resource is canonical. Do not hand-build routes, validators, HTTP helpers,
+or UI before it exists. Prefer `useCrudListScreen()`, `useCrudViewScreen()`, and
+`useCrudAddEditScreen()` for routed screens; the corresponding `useCrud*()`
+composables for routed behavior; and `useList()`, `useView()`, `useAddEdit()`,
+`useCommand()`, or `useEndpointResource()` for non-standard contracts. Standard
+CRUD derives JSON:API transport from the resource—never use raw `fetch()`.
+
+## Generated record deletion
+
+Request ordinary routed deletion explicitly:
 
-Treat that shared resource as the canonical CRUD contract. Do not hand-build
-routes, validators, HTTP helpers, or UI before the server resource exists.
+```bash
+npx --no-install jskit generate crud-ui-generator crud notes \
+  --resource-file packages/notes/src/shared/noteResource.js \
+  --id-param noteId \
+  --display-fields title,body \
+  --parent-title contextual \
+  --navigation-role primary \
+  --delete-confirmation
+```
+
+`--delete-confirmation` requires generated list and view pages and a shared
+resource with a `DELETE` operation. It supports a custom `--id-param` and fails
+clearly when the contract is unsupported. The view uses the public
+`CrudViewScreen` `actions` slot and `useCrudDeleteAction()`. A Vuetify alert
+dialog provides Cancel/Delete; `useCommand()` owns pending/error state and the
+resource request; success invalidates the CRUD list and navigates there. Do not
+inspect private `users-web` code, add a page transport, or use raw `fetch()`.
 
-Use generated high-level seams where they fit:
+## Strict temporal values
 
-- `useCrudListScreen()`, `useCrudViewScreen()`, and
-  `useCrudAddEditScreen()` for routed screens.
-- `useCrudList()`, `useCrudView()`, and `useCrudAddEdit()` for routed CRUD
-  behavior.
-- `useList()`, `useView()`, `useAddEdit()`, `useCommand()`, and
-  `useEndpointResource()` for non-standard contracts.
+With `json-rest-schema` 1.0.17, temporal resource values are strings:
 
-CRUD hooks derive their JSON:API transport from the shared resource. Do not
-pass a custom transport or use raw `fetch()` for standard CRUD behavior.
+- `date`: `YYYY-MM-DD`
+- `time`: offset-free `HH:MM[:SS[.fraction]]`
+- `dateTime`: RFC 3339 with seconds and `Z` or a numeric offset
+
+Do not pass JavaScript `Date` objects through resource validation; convert at
+the boundary (normally `toISOString()` for `dateTime`). `timestamp` is removed:
+after checking the existing unit, use `epochMilliseconds` or `epochSeconds`.
+Honor `temporalPrecision` without silently truncating fractions. Generated CRUD
+serializes supported database temporal output; custom repositories must return
+strict strings and write ISO/RFC 3339 strings themselves. There is no compatibility alias.
 
 ## Migration ownership
 
-Do not hand-write a competing migration for a table the CRUD server generator
-will own. Never modify or replace its installed baseline migration. Express a
-later schema change as a new immutable additive migration owned by the
-app-local package:
+Never compete with or alter a generator-owned baseline migration. Later schema
+changes are immutable additive migrations owned by the app-local package:
 
 ```bash
-npx jskit create migration \
-  --package <package-id> \
-  --id <migration-id>
-npx jskit migrations package <package-id>
+npx --no-install jskit create migration --package <package-id> --id <id>
+npx --no-install jskit migrations package <package-id>
 npm run db:migrate
 ```
 
-If ordinary persisted data genuinely cannot use the generated CRUD lane, stop
-and obtain explicit developer approval. Record the approved exception in
-`.jskit/WORKBOARD.md` and `.jskit/table-ownership.json`; also record it in
-`.jskit/APP_BLUEPRINT.md` when it changes durable architecture.
-
-Before sign-off, rebuild the full migration chain in a fresh disposable
-database, compare the recreated schema with the intended schema, test relevant
-ownership boundaries, run JSKIT Doctor, and run the project verifier.
+An exceptional persistence lane requires explicit developer approval recorded
+in `.jskit/WORKBOARD.md` and `.jskit/table-ownership.json`, plus
+`.jskit/APP_BLUEPRINT.md` when architectural. Before sign-off, rebuild from
+zero in a fresh disposable database, compare schema, test ownership boundaries,
+run Doctor, and run the verifier.

package/skills/jskit/references/ui-operations.md

@@ -1,73 +1,67 @@
 # UI operations
 
-Read this reference for routes, pages, surfaces, placements, responsive UI, or
-browser verification.
+Read this for routes, pages, surfaces, placements, responsive UI, and browser
+verification.
 
 ## Pages, surfaces, and placements
 
-Take the intended surface from the request and app authority; do not silently
-default new functionality to `app`. Surface choice controls routes, access,
-placement visibility, and often ownership.
-
-For a normal app-owned non-CRUD page, first inspect the generator and semantic
-placements, then generate the page:
+Take the surface from the request/app authority; it controls routes, access,
+placement visibility, and often ownership. For a normal non-CRUD page:
 
 ```bash
-npx jskit show ui-generator --details
-npx jskit list-placements
-npx jskit generate ui-generator page <route-file> --name <name>
+npx --no-install jskit show ui-generator --details
+npx --no-install jskit list-placements
+npx --no-install jskit generate ui-generator page <route-file> --name <name>
 ```
 
-Use `--navigation-role primary` for main destinations and `secondary`,
-`detail`, `workflow`, or `none` as appropriate for other routes. Use
-`--link-placement <semantic-id>` when the link belongs in a non-default slot.
-Use `npx jskit list-placements --concrete` only when diagnosing concrete
-outlets. Author normal app UI against semantic placements such as
-`shell.primary-nav` or `page.section-nav`, not raw `host:position` outlets.
+Choose the truthful `--navigation-role`. Override with semantic
+`--link-placement <area.slot>` when needed; use concrete placements only for
+diagnosis. Let the generator create the route and placement before adapting
+app-owned output. State why before hand-writing a normal page.
+
+## Managed app-owned files
 
-Let the generator create both the route and placement entry before adapting
-app-owned output. If a normal page cannot use the generator, state the concrete
-reason before hand-writing it.
+“App-owned” means customizable, not disposable while its package is installed.
+Never delete or rename a path recorded in `.jskit/lock.json`; adapt managed
+infrastructure tests in place. When replacing a starter route, update its smoke
+test to the new canonical route instead of deleting baseline browser coverage.
+Doctor must continue to report a missing managed test.
 
 ## Screen behavior
 
-- Keep app screens phone/task-first, primary actions drawer-independent, and
-  48 px tap targets.
-- Use a page header and direct `v-sheet`, not nested-card architecture.
-- Provide resource-named loading, empty, error, permission, and retry states.
-- Use compact searchable cards and medium/expanded tables for generated CRUD
-  lists where appropriate.
+- Keep screens phone/task-first with drawer-independent primary actions and
+  48 px targets. Use a page header and direct `v-sheet`, not nested cards.
+- Provide named loading, empty, error, permission, and retry states. Generated
+  lists use searchable compact cards and medium/expanded tables where suitable.
 - Extend shared CRUD screens through slots. For custom sibling/child links,
   resolve current dynamic params with their runtime to an absolute URL/route
   object; never bind its route-template/relative string raw to Vue Router `to`.
-- Use `defineCrudListRowActions(...)` and the generated page-local row-action
-  seam for row commands. Use shared filter definitions for structured filters.
-- Keep ordinary read failures local with runtime `loadError` and retry state.
-  Use `useCommand()` or `useUiFeedback()` for user-triggered action feedback.
+- Use page-local row-action/filter definitions. Keep read failures local; use
+  `useCommand()` or `useUiFeedback()` for user-triggered action feedback.
 
-## Browser verification
+## Adaptive shell drawer
 
-Any change to user-facing behavior needs a Playwright flow exercising that
-behavior. Check compact, medium, and expanded widths for generated/template UI
-changes, including overflow, clipped text, duplicate navigation, route
-placement, primary actions, and tap targets.
+Use Vuetify Material navigation. Compact close dismisses the temporary drawer.
+Wider layouts default to `desktopDrawerClosedMode="rail"`, retaining primary
+navigation as a rail. Use `desktopDrawerClosedMode="hidden"` only when another
+discoverable navigation affordance exists. Do not create a second drawer/menu
+registry or imitate the rail with CSS.
 
-Use relative URLs in tests. The shared JSKIT Playwright config owns the base
-URL, server lifecycle, and storage state. When `PLAYWRIGHT_BASE_URL` is set,
-do not start another server. When
-`VIBE64_PLAYWRIGHT_STORAGE_STATE` is supplied, do not print, commit, or retain
-it and do not use local login bypasses. Do not install a browser when the
-environment supplies a managed runner.
+## Browser verification
 
-For a direct localhost app with development auth bypass explicitly enabled,
-use `loginAsExistingUser()` from `@jskit-ai/auth-web/test/playwright`; never
-send the bypass secret through browser globals, query parameters, or client
-environment variables.
+Exercise user-facing changes with Playwright at compact, medium, and expanded
+widths. Check overflow, clipped text, duplicate navigation, route placement,
+actions, and target sizes. Use relative URLs; shared JSKIT config owns base URL,
+server, and storage state. With `PLAYWRIGHT_BASE_URL`, start no server. Never
+print/commit `VIBE64_PLAYWRIGHT_STORAGE_STATE`, use a local bypass with it, or
+install a browser when a managed runner supplies one.
 
-After a successful UI test, record the verification when the app supports it:
+For explicitly enabled direct-local auth, use `loginAsExistingUser()` from
+`@jskit-ai/auth-web/test/playwright`; never expose its secret to browser code,
+URLs, or client env. Record a successful supported run with:
 
 ```bash
-npx jskit app verify-ui \
+npx --no-install jskit app verify-ui \
   --command "<exact successful Playwright command>" \
   --feature "<changed behavior>" \
   --auth-mode <dev-auth-login-as|session-bootstrap>