@jskit-ai/agent-docs 0.1.131 → 0.1.133

package/patterns/minimal-foundation/example/server.js

@@ -0,0 +1,195 @@
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import { resolveRuntimeEnv } from "./server/lib/runtimeEnv.js";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import {
+  createInstalledRuntime,
+  registerSurfaceRequestConstraint,
+  resolveRuntimeProfileFromSurface
+} from "@jskit-ai/kernel/server/platform";
+import { loadAppConfigFromAppRoot } from "@jskit-ai/kernel/server/support";
+import { matchesPathPrefix, normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
+import { surfaceRuntime } from "./server/lib/surfaceRuntime.js";
+
+const SPA_INDEX_FILE = "index.html";
+const API_BASE_PATH = "/api";
+const STATIC_GLOBAL_UI_PATHS = Object.freeze([
+  "/assets",
+  "/favicon.svg",
+  "/favicon.ico",
+  "/robots.txt",
+  "/manifest.webmanifest"
+]);
+
+function toRequestPathname(urlValue) {
+  const rawUrl = String(urlValue || "").trim() || "/";
+  try {
+    return normalizePathname(new URL(rawUrl, "http://localhost").pathname || "/");
+  } catch {
+    return normalizePathname(rawUrl.split("?")[0] || "/");
+  }
+}
+
+function isApiPath(pathname) {
+  return matchesPathPrefix(pathname, API_BASE_PATH);
+}
+
+function hasFileExtension(pathname) {
+  return path.extname(normalizePathname(pathname)) !== "";
+}
+
+function resolveGlobalUiPaths(runtimeGlobalUiPaths = []) {
+  const paths = new Set(Array.isArray(runtimeGlobalUiPaths) ? runtimeGlobalUiPaths : []);
+  for (const staticPath of STATIC_GLOBAL_UI_PATHS) {
+    paths.add(staticPath);
+  }
+  return [...paths];
+}
+
+function resolveStaticFilePath(pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+
+  const relativePath = normalizedPathname.replace(/^\/+/, "");
+  if (!relativePath || relativePath.endsWith("/")) {
+    return "";
+  }
+
+  const normalizedRelativePath = path.posix.normalize(relativePath);
+  if (
+    !normalizedRelativePath ||
+    normalizedRelativePath === "." ||
+    normalizedRelativePath === ".." ||
+    normalizedRelativePath.startsWith("../") ||
+    normalizedRelativePath.includes("/../")
+  ) {
+    return "";
+  }
+
+  return normalizedRelativePath;
+}
+
+function canServeStaticFile(distRoot, relativePath) {
+  if (!distRoot || !relativePath) {
+    return false;
+  }
+
+  const normalizedDistRoot = path.resolve(distRoot);
+  const resolvedPath = path.resolve(normalizedDistRoot, relativePath);
+  if (!(resolvedPath === normalizedDistRoot || resolvedPath.startsWith(`${normalizedDistRoot}${path.sep}`))) {
+    return false;
+  }
+
+  return existsSync(resolvedPath);
+}
+
+async function createServer({ runtimeEnv = resolveRuntimeEnv() } = {}) {
+  const app = Fastify({
+    logger: true,
+    ajv: {
+      customOptions: {
+        allowUnionTypes: true
+      }
+    }
+  });
+
+  app.get("/api/health", async () => {
+    return {
+      ok: true,
+      app: "reading-room"
+    };
+  });
+  const appRoot = path.resolve(process.cwd());
+  const distRoot = path.resolve(appRoot, "dist");
+  const hasWebBuild = existsSync(path.resolve(distRoot, SPA_INDEX_FILE));
+  const spaDocument = hasWebBuild ? readFileSync(path.resolve(distRoot, SPA_INDEX_FILE), "utf8") : "";
+  const runtime = await createInstalledRuntime({
+    appRoot,
+    profile: resolveRuntimeProfileFromSurface({
+      surfaceRuntime,
+      serverSurface: runtimeEnv.SERVER_SURFACE
+    }),
+    config: await loadAppConfigFromAppRoot({ appRoot }),
+    env: runtimeEnv,
+    logger: app.log,
+    fastify: app
+  });
+
+  registerSurfaceRequestConstraint({
+    fastify: app,
+    surfaceRuntime,
+    serverSurface: runtimeEnv.SERVER_SURFACE,
+    globalUiPaths: resolveGlobalUiPaths(runtime?.globalUiPaths || [])
+  });
+
+  if (hasWebBuild) {
+    await app.register(fastifyStatic, {
+      root: distRoot,
+      index: false,
+      serve: false
+    });
+  } else {
+    app.log.warn("Frontend build not found (dist/index.html). Page routes will return 404 until `npm run build`.");
+  }
+
+  app.setNotFoundHandler(async (request, reply) => {
+    const pathname = toRequestPathname(request?.url);
+    const method = String(request?.method || "GET")
+      .trim()
+      .toUpperCase();
+    if (isApiPath(pathname) || (method !== "GET" && method !== "HEAD")) {
+      return reply.code(404).send({
+        message: `Route ${method}:${pathname} not found`,
+        error: "Not Found",
+        statusCode: 404
+      });
+    }
+    if (hasFileExtension(pathname)) {
+      const staticFilePath = resolveStaticFilePath(pathname);
+      if (hasWebBuild && staticFilePath && canServeStaticFile(distRoot, staticFilePath)) {
+        return reply.sendFile(staticFilePath);
+      }
+      return reply.code(404).send({
+        message: `Route ${method}:${pathname} not found`,
+        error: "Not Found",
+        statusCode: 404
+      });
+    }
+    if (!hasWebBuild) {
+      return reply.code(404).send({
+        error: "Frontend build is not available. Run `npm run build`."
+      });
+    }
+    return reply.type("text/html; charset=utf-8").send(spaDocument);
+  });
+
+  app.log.info(
+    {
+      surface: surfaceRuntime.normalizeSurfaceMode(runtimeEnv.SERVER_SURFACE),
+      providerPackages: runtime.providerPackageOrder,
+      packageOrder: runtime.packageOrder,
+      capabilities: runtime.diagnostics.capabilityIds
+    },
+    "Started JSKIT installed runtime."
+  );
+
+  return app;
+}
+
+async function startServer(options = {}) {
+  const runtimeEnv = resolveRuntimeEnv();
+  const configuredPort = options?.port === undefined ? runtimeEnv.PORT : Number(options.port);
+  const port = Number.isInteger(configuredPort) && configuredPort >= 0 ? configuredPort : runtimeEnv.PORT;
+  const host = String(options?.host || "").trim() || runtimeEnv.HOST;
+  const app = await createServer({
+    runtimeEnv: {
+      ...runtimeEnv,
+      HOST: host,
+      PORT: port
+    }
+  });
+  await app.listen({ port, host });
+  return app;
+}
+
+export { createServer, startServer };

package/patterns/minimal-foundation/example/src/App.vue

@@ -0,0 +1,13 @@
+<template>
+  <v-app>
+    <v-main>
+      <v-container class="py-10 py-md-14">
+        <v-row justify="center">
+          <v-col cols="12" sm="11" md="10" lg="8" xl="7">
+            <RouterView />
+          </v-col>
+        </v-row>
+      </v-container>
+    </v-main>
+  </v-app>
+</template>

package/patterns/minimal-foundation/example/src/main.js

@@ -0,0 +1,85 @@
+import { createApp } from "vue";
+import { createPinia } from "pinia";
+import { QueryClient, VueQueryPlugin } from "@tanstack/vue-query";
+import { createRouter, createWebHistory } from "vue-router/auto";
+import { routes } from "vue-router/auto-routes";
+import "vuetify/styles";
+import { createVuetify } from "vuetify";
+import { aliases as mdiAliases, mdi } from "vuetify/iconsets/mdi-svg";
+import App from "./App.vue";
+import NotFoundView from "./views/NotFound.vue";
+import { bootInstalledClientModules } from "virtual:jskit-client-bootstrap";
+import { createSurfaceRuntime } from "@jskit-ai/kernel/shared/surface/runtime";
+import {
+  shouldRetryTransientQueryFailure,
+  transientQueryRetryDelay
+} from "@jskit-ai/kernel/shared/support";
+import {
+  bootstrapClientShellApp,
+  createShellRouter
+} from "@jskit-ai/kernel/client";
+import { config } from "../config/public.js";
+
+const surfaceRuntime = createSurfaceRuntime({
+  allMode: config.surfaceModeAll,
+  surfaces: config.surfaceDefinitions,
+  defaultSurfaceId: config.surfaceDefaultId
+});
+
+const surfaceMode = surfaceRuntime.normalizeSurfaceMode(import.meta.env.VITE_SURFACE);
+const { router, fallbackRoute } = createShellRouter({
+  createRouter,
+  history: createWebHistory(),
+  routes,
+  surfaceRuntime,
+  surfaceMode,
+  notFoundComponent: NotFoundView,
+  guard: {
+    surfaceDefinitions: config.surfaceDefinitions,
+    defaultSurfaceId: config.surfaceDefaultId,
+    webRootAllowed: config.webRootAllowed
+  }
+});
+
+const vuetify = createVuetify({
+  theme: {
+    defaultTheme: "light"
+  },
+  icons: {
+    defaultSet: "mdi",
+    aliases: mdiAliases,
+    sets: { mdi }
+  }
+});
+const pinia = createPinia();
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: true,
+      retry: shouldRetryTransientQueryFailure,
+      retryDelay: transientQueryRetryDelay
+    }
+  }
+});
+
+void bootstrapClientShellApp({
+  createApp,
+  rootComponent: App,
+  appConfig: config,
+  appPlugins: [
+    pinia,
+    [VueQueryPlugin, { queryClient }],
+    vuetify
+  ],
+  pinia,
+  queryClient,
+  router,
+  bootClientModules: bootInstalledClientModules,
+  surfaceRuntime,
+  surfaceMode,
+  env: import.meta.env,
+  fallbackRoute
+}).catch((error) => {
+  console.error("Failed to bootstrap client app.", error);
+});

package/patterns/minimal-foundation/example/src/pages/home/index.vue

@@ -0,0 +1,48 @@
+<template>
+  <section class="home-start-screen d-flex flex-column ga-4">
+    <header>
+      <p class="text-overline text-medium-emphasis mb-1">Home</p>
+      <h1 class="home-start-screen__title">Home base</h1>
+      <p class="text-body-2 text-medium-emphasis mb-0">
+        The app runtime is online and ready for the first real workflow.
+      </p>
+    </header>
+
+    <v-sheet rounded="lg" border class="home-start-screen__panel">
+      <h2 class="text-h6 mb-2">No activity yet</h2>
+      <p class="text-body-2 text-medium-emphasis mb-0">
+        Recent work, saved records, and next actions will appear here once this app has data.
+      </p>
+    </v-sheet>
+  </section>
+</template>
+
+<style scoped>
+.home-start-screen {
+  --home-start-title-size: 2rem;
+  --home-start-panel-padding: 1rem;
+}
+
+.home-start-screen {
+  margin-inline: auto;
+  max-width: 48rem;
+}
+
+.home-start-screen__title {
+  font-size: var(--home-start-title-size);
+  font-weight: 700;
+  letter-spacing: 0;
+  line-height: 1.08;
+  margin: 0 0 0.45rem;
+}
+
+.home-start-screen__panel {
+  padding: var(--home-start-panel-padding);
+}
+
+@media (max-width: 640px) {
+  .home-start-screen {
+    --home-start-title-size: 1.5rem;
+  }
+}
+</style>

package/patterns/minimal-foundation/example/src/pages/home.vue

@@ -0,0 +1,13 @@
+<route lang="json">
+{
+  "meta": {
+    "jskit": {
+      "surface": "home"
+    }
+  }
+}
+</route>
+
+<template>
+  <RouterView />
+</template>

package/patterns/minimal-foundation/example/src/views/NotFound.vue

@@ -0,0 +1,13 @@
+<script setup>
+const title = "Not Found";
+const message = "The page you requested does not exist.";
+</script>
+
+<template>
+  <v-container class="fill-height d-flex align-center justify-center">
+    <v-card class="pa-6 text-center" max-width="560" rounded="lg">
+      <v-card-title class="text-h4">{{ title }}</v-card-title>
+      <v-card-text class="text-medium-emphasis">{{ message }}</v-card-text>
+    </v-card>
+  </v-container>
+</template>

package/patterns/minimal-foundation/example/tests/client/smoke.vitest.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+
+describe("reading-room client smoke", () => {
+  it("runs vitest in reading-room", () => {
+    expect(true).toBe(true);
+  });
+});

package/patterns/minimal-foundation/example/tests/e2e/base-shell.spec.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "@playwright/test";
+
+const VIEWPORTS = Object.freeze([
+  Object.freeze({ name: "compact", width: 390, height: 844 }),
+  Object.freeze({ name: "medium", width: 768, height: 1024 }),
+  Object.freeze({ name: "expanded", width: 1280, height: 900 })
+]);
+
+test.describe("application responsive smoke", () => {
+  for (const viewport of VIEWPORTS) {
+    test(`${viewport.name} home route renders without horizontal overflow`, async ({ page }) => {
+      await page.setViewportSize(viewport);
+      await page.goto("/home");
+      await expect(page.getByRole("heading", { name: "Home base" })).toBeVisible();
+
+      const dimensions = await page.evaluate(() => ({
+        clientWidth: document.documentElement.clientWidth,
+        scrollWidth: document.documentElement.scrollWidth
+      }));
+      expect(dimensions.scrollWidth).toBeLessThanOrEqual(dimensions.clientWidth + 1);
+    });
+  }
+});

package/patterns/minimal-foundation/example/tests/server/smoke.test.js

@@ -0,0 +1,16 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createServer } from "../../server.js";
+
+test("GET /api/health returns built-in health response", async () => {
+  const app = await createServer();
+  const response = await app.inject({
+    method: "GET",
+    url: "/api/health"
+  });
+
+  assert.equal(response.statusCode, 200);
+  assert.equal(response.json().ok, true);
+
+  await app.close();
+});

package/patterns/minimal-foundation/example/vite.config.mjs

@@ -0,0 +1,81 @@
+import { fileURLToPath, URL } from "node:url";
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vuetify from "vite-plugin-vuetify";
+import VueRouter from "vue-router/vite";
+import { createJskitClientBootstrapPlugin } from "@jskit-ai/kernel/client/vite";
+
+const configuredDevPort = Number.parseInt(String(process.env.VITE_DEV_PORT || "").trim(), 10);
+const devPort = Number.isInteger(configuredDevPort) && configuredDevPort > 0 ? configuredDevPort : 5173;
+const apiProxyTarget = String(process.env.VITE_API_PROXY_TARGET || "").trim() || "http://localhost:3000";
+const clientEntry = (() => {
+  const normalized = String(process.env.VITE_CLIENT_ENTRY || "").trim();
+  if (!normalized) {
+    return "/src/main.js";
+  }
+  if (normalized.startsWith("/")) {
+    return normalized;
+  }
+  if (normalized.startsWith("src/")) {
+    return `/${normalized}`;
+  }
+  return `/src/${normalized}`;
+})();
+
+export default defineConfig({
+  resolve: {
+    preserveSymlinks: true,
+    alias: {
+      "@": fileURLToPath(new URL("./src", import.meta.url))
+    }
+  },
+  plugins: [
+    createJskitClientBootstrapPlugin({
+      proxyTarget: apiProxyTarget
+    }),
+    VueRouter({
+      routesFolder: "src/pages",
+      // Generated on the first Vite dev/build scan and intentionally gitignored.
+      dts: "src/typed-router.d.ts",
+      nestedChildren: false
+    }),
+    vue(),
+    vuetify({
+      autoImport: true
+    }),
+    {
+      name: "jskit-client-entry",
+      transformIndexHtml(source) {
+        return String(source || "")
+          .replace(/\/src\/%VITE_CLIENT_ENTRY%/g, clientEntry)
+          .replace(/\/src\/main\.js/g, clientEntry);
+      }
+    }
+  ],
+  test: {
+    include: ["tests/client/**/*.vitest.js"]
+  },
+  optimizeDeps: {
+    entries: [
+      "index.html",
+      "src/**/*.{js,ts,vue}"
+    ]
+  },
+  server: {
+    port: devPort,
+    warmup: {
+      clientFiles: [
+        "src/main.{js,ts}",
+        "src/router/**/*.{js,ts}",
+        "src/pages/**/*.{js,ts,vue}",
+        "src/components/**/*.{js,ts,vue}"
+      ]
+    },
+    proxy: {
+      "/api": {
+        target: apiProxyTarget,
+        changeOrigin: true
+      }
+    }
+  }
+});

package/patterns/page-scaffolding.md

@@ -5,44 +5,47 @@ Use when:
 - adding a non-CRUD route page
 - adding a placeholder page or screen stub
 - adding a menu-linked page
-- deciding whether a page and its link should be generated or hand-written
+- deciding how a page and its link should fit the current application
 
 Check first:
 
 - the app blueprint route family and chosen surface
-- `jskit show ui-generator --details`
-- `jskit list-placements`
+- the page-and-placement source pattern
+- the current placement declarations and topology
 - the nearest existing routed host under `src/pages`
 
 Rules:
 
-- Default to `jskit generate ui-generator page ...` for a new app-owned non-CRUD route page.
-- Let the generator create both the page file and the matching `src/placement.js` entry, then adapt the generated output if needed.
-- Choose the generated page's product navigation role deliberately. Use `--navigation-role primary` for main destinations, `secondary` for lower-priority shell links, and `detail`, `workflow`, or `none` when the page should not appear in navigation.
-- If the page link belongs in a non-default semantic slot, discover the public placement first with `jskit list-placements` and pass `--link-placement`.
-- If you need the concrete outlet inventory, use `jskit list-placements --concrete`; do not target concrete outlets by default.
-- If the page sits under an existing routed host, check whether `ui-generator page` can infer the correct `page.section-nav` owner before writing a custom link by hand.
-- If you do not use `ui-generator page`, state exactly why the generator does not fit before editing code.
+- Start from the package-owned page-and-placement pattern for a new app-owned
+  non-CRUD route, then adapt the page and placement as ordinary source.
+- Create both the page file and matching `src/placement.js` entry when the page
+  belongs in navigation.
+- Choose the page's product navigation role deliberately: primary for main
+  destinations, secondary for lower-priority shell links, and detail,
+  workflow, or no placement when the page should not appear in navigation.
+- Inspect the installed packages' public placement declarations before using
+  a semantic slot. Target concrete outlets only for deliberate infrastructure.
+- If the page sits under an existing routed host, reuse its `page.section-nav`
+  ownership rather than creating a parallel navigation structure.
 - For a small placeholder route inside an existing route family, keep the change scoped unless the durable route or surface plan in the app blueprint changed.
-- Generated live pages must be usable screens, not instructional scaffolds. Do not ship copy such as "replace this", "use this area", or "this page is ready".
-- Prefer a page header plus a direct `v-sheet` working region. Do not wrap every generated page in a generic `v-card`.
+- Live pages must be usable screens, not instructional scaffolds. Do not ship copy such as "replace this", "use this area", or "this page is ready".
+- Prefer a page header plus a direct `v-sheet` working region. Do not wrap every page in a generic `v-card`.
 - If the screen is not implemented yet, use a product-shaped empty state with one clear next action or status, not developer instructions.
-- Primary navigation links belong in semantic placements such as `shell.primary-nav` or `page.section-nav`; do not place every generated route into one drawer by default.
+- Primary navigation links belong in semantic placements such as `shell.primary-nav` or `page.section-nav`; do not place every route into one drawer by default.
 - Compact layouts must be checked first: no horizontal overflow, no unreachable primary action, and tap targets should be at least 48 px.
 
-Generated UI contract:
+UI contract:
 
 - App-facing screens are phone-first and task-first; admin/console screens may be denser but still need responsive controls.
 - Navigation uses semantic placements by default. Raw `host:position` outlets are advanced infrastructure.
 - Page architecture is header plus direct work region, normally `v-sheet`; do not use generic page-level `v-card` shells.
 - Empty/loading/error states are product-shaped and resource-named.
 - Detail and workflow routes are not primary navigation by default.
-- Generated UI must have compact, medium, and expanded browser checks when it changes user-facing behavior.
+- Changed UI must have compact, medium, and expanded browser checks when it changes user-facing behavior.
 
 Avoid:
 
-- hand-writing both `src/pages/...` and `src/placement.js` for a normal non-CRUD page before checking `ui-generator`
+- inventing a page and placement shape without checking the existing pattern and neighboring routes
 - treating a small page stub as permission to rewrite marketing copy, route architecture, or app blueprint scope
-- claiming that no generator exists without checking the actual `jskit` generator inventory first
 - adding cards inside cards or repeating the page title inside a card title
 - treating Vuetify component defaults as the product architecture

package/patterns/placements.md

@@ -45,8 +45,8 @@ Placement topology:
 - Every variant needs an `outlet: "host:position"`.
 - Variant `renderers` maps semantic `kind` values to component tokens, for example `renderers: { link: "local.main.ui.surface-aware-menu-link-item" }`.
 - Renderer choice for semantic `kind: "link"` placements belongs in topology, not in each placement entry.
-- `default: true` marks the fallback semantic placement that page generators use when no nearer host applies.
-- Package topology is discovered too, but app topology with the same `id` and `owner` overrides package topology in CLI discovery.
+- `default: true` marks the fallback semantic placement that app-owned pages use when no nearer host applies.
+- Package topology is discovered too, but app topology with the same `id` and `owner` overrides package topology.
 
 Runtime behavior:
 
@@ -62,21 +62,23 @@ Runtime behavior:
 - On medium and expanded layouts, closing the standard drawer produces an 80px Material navigation rail by default. Expanded and collapsed icons share one centreline. Use `railWidth` to configure an intentionally denser rail, or `desktopDrawerClosedMode="hidden"` only when another discoverable navigation surface exists.
 - The shell link renderers own rail centring, selected-state treatment, and opaque theme-aware tooltips. Applications should keep supplying the same semantic placement records rather than creating rail-only links or tooltip CSS.
 
-CLI and generators:
-
-- `jskit list-placements` shows semantic placements by default.
-- `jskit list-placements --concrete` shows concrete `ShellOutlet` recipients.
-- `jskit list-placements --all` shows both.
-- `jskit list-placements --json` returns structured semantic and concrete placement data.
-- `ui-generator page`, CRUD UI list generation, and assistant page generation target semantic placements.
-- `--link-placement` for generated pages is a semantic placement id, not a concrete outlet id.
-- If a generated page is under a parent host with a mapped `ShellOutlet`, the generator infers the semantic placement and owner from topology.
-- `ui-generator add-subpages` upgrades a page into a routed child-page host and appends a `page.section-nav` topology entry for the generated concrete outlet.
-- `ui-generator outlet` injects a plain concrete `ShellOutlet` and appends the semantic topology mapping in the same command.
-- `ui-generator page` and `crud-ui-generator crud` accept `--navigation-role` so detail, workflow, and utility routes do not accidentally become primary navigation.
+Authoring and inspection:
+
+- Read package placement contributions and the app's `src/placement.js` and
+  `src/placementTopology.js` directly; they are the complete current state.
+- Source patterns for pages, CRUD UI, and assistant UI target semantic
+  placements rather than concrete outlets.
+- A page under a parent host with a mapped `ShellOutlet` should use the
+  topology's semantic placement and owner.
+- Upgrading a page into a routed child-page host includes a
+  `page.section-nav` topology entry for its concrete outlet in the same change.
+- Adding a concrete `ShellOutlet` includes its semantic topology mapping in the
+  same change.
+- Detail, workflow, and utility routes should not accidentally become primary
+  navigation entries.
 - `page.supporting-content` is the default semantic place for supporting detail/content overlays. The default shell maps it to a closed compact bottom sheet and a closed medium/expanded side panel.
 - When adding a public concrete outlet by hand, add its semantic topology mapping in the same change.
-- If `jskit list-placements` reports unmapped concrete outlets, either add semantic topology for them or keep those outlets private/internal.
+- Keep every public concrete outlet mapped by semantic topology; otherwise keep it private/internal.
 
 Rules:
 

package/patterns/row-policies.md

@@ -9,10 +9,9 @@ Use when:
 
 Read first:
 
-- `packages/agent-docs/site/guide/generators/row-policies.md`
 - the owning CRUD provider and shared resource
-- the generated CRUD repository and service templates
-- `packages/crud-server-generator/test/crudService.test.js`
+- the package-owned CRUD server pattern
+- `packages/crud-core/test/defineCrudJsonApiFeature.test.js`
 
 Default JSKIT pattern:
 
@@ -60,7 +59,7 @@ Avoid:
 
 - filtering `document.data` in `service.js`
 - accepting visible ids or hierarchy roots from client query parameters
-- installing `RowPolicyPlugin` in generated applications
-- adding a default policy file to every generated CRUD
+- installing `RowPolicyPlugin` in applications
+- adding a default policy file to every CRUD
 - returning a Knex builder or promise from a synchronous grouped contribution
 - swallowing a policy error and retrying without mandatory visibility