@jskit-ai/agent-docs 0.1.257 → 0.1.259

package/guide/agent/framework/ui-operations.md

@@ -103,8 +103,8 @@ For Back, enter the same page from two different origins and verify each
 returns to its own origin with context intact. Also check direct entry, reload,
 browser back/forward, fixed-destination exceptions, and any unsaved-change guard.
 
-Vibe64 owns its managed browser and may provide
-`VIBE64_PLAYWRIGHT_STORAGE_STATE`; never print or commit that value, bypass it,
+A managed host owns its browser and may provide
+`PLAYWRIGHT_STORAGE_STATE`; never print or commit that value, bypass it,
 or install another browser. For explicitly enabled direct-local auth, use
 `loginAsExistingUser()` from `@jskit-ai/auth-web/test/playwright`; never expose
 the exchange secret to browser code, URLs, or client environment.

package/guide/agent/index.md

@@ -26,6 +26,10 @@ apply or adapt. It does not prescribe an agent host or project orchestrator.
 - [Application operations](/guide/framework/application-operations)
 - [CRUD operations](/guide/framework/crud-operations)
 - [Record form actions](/guide/framework/crud-form-actions)
+- [Typed features](/guide/framework/typed-features): read before writing any
+  server feature, provider, action, service or repository
+- [Client features](/guide/framework/client-features): read before writing any
+  composable, component, client factory or client provider
 - [UI operations](/guide/framework/ui-operations)
 - [Material 3](/guide/framework/material-3)
 - [Translating a JSKIT app](/guide/framework/translation)
@@ -42,7 +46,8 @@ apply or adapt. It does not prescribe an agent host or project orchestrator.
 ## How to use the guide
 
 Begin with the Quickstart and one application-foundation pattern. Add only the
-capabilities selected by the product. The public pattern library contains every
+capabilities selected by the product. Server code follows Typed features from
+its first line; the foundations' lint configuration reports what breaks it. The public pattern library contains every
 published `PATTERN.md` and links its complete example tree. If a runtime package
 is installed, its package-owned copy is the version-matched implementation
 reference. The optional standalone JSKIT Agent Skill bundles the same pattern

package/package.json

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

package/patterns/feature-package/PATTERN.md

@@ -42,8 +42,43 @@ questionnaire.
   the feature package.
 - `defineFeature()` receives only declared capabilities and returns only
   declared feature APIs.
-- Actions define the public operation contract and close over the feature APIs
-  they need. They never resolve arbitrary dependencies at execution time.
+- Each provided capability exports its type. A named `create<Name>` factory in
+  its own module builds the value `setup()` returns, and `types.js` declares
+  one `@typedef` per provided token, named after the token in PascalCase
+  (`feature.booking-engine` -> `BookingEngine`). A package exports it as
+  `./server/types`.
+- Every factory, action creator and hook that receives a collaborator names its
+  type in a JSDoc `@param`: `import("./types.js").<Name>` or
+  `ReturnType<typeof createX>` inside the package, the owner's `./server/types`
+  across packages; a Knex client is database-runtime's `RuntimeKnex`.
+- Collaborators are required. There is no `= null`, `= {}` or no-op default,
+  no `typeof` probe, no optional call and no "requires x" guard: the capability
+  runtime refuses to start without a required token.
+- An extension point is an `optional` token whose default the package names
+  in a module of its own and `setup()` resolves once with `??`, never a setter
+  that fills a slot later or a module-level registry. The token is typed
+  `X | null` only in `setup()`; what `setup()` builds receives it as required.
+- One `create<Name>Actions({ <api> })` per feature, destructured, in
+  `<name>Actions.js`, creates its actions and closes over the feature APIs they
+  need. Every definition and the list are frozen. Each definition spreads one
+  frozen constant of the fields its kind shares (`version`, `kind`,
+  `channels`, `surfaces`) first. Each id is a string literal or a module-level
+  constant, and `execute: (input, context) => api.method(input, { context })`
+  is one call, without `async`, a body, an envelope or a helper that builds or
+  strips it. Actions never resolve arbitrary dependencies at execution time.
+- Methods take the validated input as it is: no `input = {}` default, no
+  `input?.x` and no second normalization of fields the input schema already
+  checked. An options bag whose fields are optional by contract
+  (`options = {}` with `trx`) keeps its default.
+- The package reads the actor from an action context one way, with the
+  kernel's `resolveActorId(context)` or `resolveActor(context)`
+  (`@jskit-ai/kernel/server/actions/actionContributorHelpers`), and its actions
+  pass the context one way.
+- Every `create*` returns `Object.freeze({ … })` of named inner functions, and
+  exposes another factory's functions by name, never by spreading it.
+- A description sits inside its `/** */` block, never in a `//` line above it.
+- One copy of each pure helper per package, imported directly. Files stay under
+  750 lines and functions under 600, one concern per factory.
 - The service orchestrates the feature and does not issue SQL directly.
 - A repository owns persistence and accepts transaction/context options.
 - The normal persistence lane uses a public or documented high-level resource
@@ -68,20 +103,65 @@ The custom persistence variation uses `createWithTransaction()` from
 ## Example files
 
 `example/booking-engine/` is a concrete app-local package showing the preferred
-small-feature boundary. Its status query is deliberately small: product logic
-can grow inside the returned feature API without creating ceremonial layers.
-
-`example/variations/AvailabilityEngineProvider.js` and
+small-feature boundary:
+
+- `src/server/BookingEngineFeature.js` declares the feature, its optional
+  `feature.booking-engine.availability` slot and the engine it provides;
+- `src/server/bookingEngine.js` builds the engine with `createBookingEngine()`,
+  a frozen object of named functions, and reads who asked with the kernel's
+  `resolveActorId(context)`;
+- `src/server/bookingAvailability.js` names the slot's default,
+  `everyScopeOpen`;
+- `src/server/bookingEngineActions.js` creates its one-line, frozen actions
+  with `createBookingEngineActions({ bookingEngine })`, each spreading the
+  shared `BOOKING_QUERY` fields first;
+- `src/server/types.js` declares `BookingEngine` and
+  `BookingEngineAvailability`, exported as `./server/types`.
+
+Its status query is deliberately small: product logic can grow inside the
+returned feature API without creating ceremonial layers. The feature resolves
+the slot once:
+
+```js
+optional: {
+  availability: "feature.booking-engine.availability"
+},
+/** @param {{ availability: import("./types.js").BookingEngineAvailability | null }} capabilities */
+setup({ availability }) {
+  return { bookingEngine: createBookingEngine({ availability: availability ?? everyScopeOpen }) };
+},
+```
+
+Another package fills the slot by providing the token, never by calling a
+setter:
+
+```js
+const SeasonalAvailabilityFeature = defineFeature({
+  id: "feature.seasonal-availability",
+  provides: { availability: "feature.booking-engine.availability" },
+  setup: () => ({ availability: isInSeason })
+});
+```
+
+`example/variations/AvailabilityEngineFeature.js`,
+`example/variations/availabilityEngineActions.js` and
 `example/variations/orchestratorService.js` show the repository-free lane.
-`example/variations/InvoiceRollupProvider.js` and
+`example/variations/InvoiceRollupFeature.js`,
+`example/variations/invoiceRollupActions.js` and
 `example/variations/customKnexRepository.js` show the explicit custom
-persistence lane.
+persistence lane. `example/variations/types.js` declares the
+`AvailabilityEngine` and `InvoiceRollup` types.
+
+The [typed features guide](https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features)
+explains each rule this example follows, with a good and a bad example, and
+`npm run lint` checks the ones a machine can see.
 
 ## Variation points
 
 Rename the package, capability id, actions, validators, and domain methods.
-Select the correct channels and surfaces in `actionDefaults`, overriding them
-only for exceptional actions. Add a service when orchestration is shared or
+Select the channels and surfaces in the shared-field constant each definition
+spreads first; a kind of action whose values differ gets a constant of its
+own. Add a service when orchestration is shared or
 stateful. Add a repository only when the feature owns persistence. Replace the
 illustrative status query with narrow product language before shipping.
 
@@ -104,5 +184,19 @@ illustrative status query with narrow product language before shipping.
 - a repository for an orchestration-only feature
 - generic `execute(anything)` operations in finished product code
 - `app.make()`, `scope.make()`, container tokens, or service-location helpers
+- probing a collaborator (`typeof x.method === "function"`, `x?.method?.()`)
+  before calling it
+- absent defaults on a collaborator or on the dependencies object (`= null`,
+  `= {}`, a no-op)
+- setters that fill a slot after construction, and module-level registries
+- a collaborator accepted in two shapes (`capability.service || capability`)
+- an `async` `execute`, an `execute` with a body, or a helper that builds an
+  action or strips its input
+- a hand-written `(...args: any[]) => Promise<any>` type instead of the
+  owner's type, and the same `ReturnType<…>` or indexed type spelled out in
+  several files
+- spreading an in-package factory's result into a provided value
+- unfrozen `create*` results and inline methods
+- a guard, default or comment that exists for a test double
 - metadata claiming which authoring tool or pattern created the package
 - field questionnaires, overwrite switches, or durable operation records

package/patterns/feature-package/example/booking-engine/package.json

@@ -5,11 +5,12 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/kernel": "0.2.3",
+    "@jskit-ai/kernel": "0.2.4",
     "json-rest-schema": "^1.0.17"
   },
   "exports": {
-    "./server/actions": "./src/server/actions.js"
+    "./server/actions": "./src/server/bookingEngineActions.js",
+    "./server/types": "./src/server/types.js"
   },
   "jskit": {
     "kind": "runtime",
@@ -25,8 +26,8 @@
       "server": {
         "providers": [
           {
-            "entrypoint": "src/server/BookingEngineProvider.js",
-            "export": "BookingEngineProvider"
+            "entrypoint": "src/server/BookingEngineFeature.js",
+            "export": "BookingEngineFeature"
           }
         ]
       },
@@ -40,6 +41,10 @@
           {
             "subpath": "./server/actions",
             "summary": "Exports booking-engine action definitions."
+          },
+          {
+            "subpath": "./server/types",
+            "summary": "Types of the feature.booking-engine capability and its optional feature.booking-engine.availability slot."
           }
         ]
       }

package/patterns/feature-package/example/booking-engine/src/server/BookingEngineFeature.js

@@ -0,0 +1,24 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { everyScopeOpen } from "./bookingAvailability.js";
+import { createBookingEngine } from "./bookingEngine.js";
+import { createBookingEngineActions } from "./bookingEngineActions.js";
+
+const BookingEngineFeature = defineFeature({
+  id: "feature.booking-engine",
+  domain: "booking",
+  optional: {
+    availability: "feature.booking-engine.availability"
+  },
+  provides: {
+    bookingEngine: "feature.booking-engine"
+  },
+  /** @param {{ availability: import("./types.js").BookingEngineAvailability | null }} capabilities */
+  setup({ availability }) {
+    return { bookingEngine: createBookingEngine({ availability: availability ?? everyScopeOpen }) };
+  },
+  actions({ bookingEngine }) {
+    return createBookingEngineActions({ bookingEngine });
+  }
+});
+
+export { BookingEngineFeature };

package/patterns/feature-package/example/booking-engine/src/server/bookingAvailability.js

@@ -0,0 +1,10 @@
+/**
+ * The `feature.booking-engine.availability` default when no package provides
+ * one: every scope takes bookings.
+ * @type {import("./types.js").BookingEngineAvailability}
+ */
+async function everyScopeOpen() {
+  return true;
+}
+
+export { everyScopeOpen };

package/patterns/feature-package/example/booking-engine/src/server/bookingEngine.js

@@ -0,0 +1,29 @@
+import { resolveActorId } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+
+/**
+ * The booking engine the feature provides as `feature.booking-engine`.
+ * @param {object} dependencies
+ * @param {import("./types.js").BookingEngineAvailability} dependencies.availability
+ */
+function createBookingEngine({ availability }) {
+  /**
+   * Reports, for the validated query, whether its scope takes bookings and who
+   * asked.
+   * @param {{ scope?: string, verbose?: boolean }} query
+   * @param {{ context: object }} options
+   */
+  async function readStatus({ scope = "default", verbose = false }, { context }) {
+    return {
+      ok: true,
+      feature: "booking-engine",
+      scope,
+      verbose,
+      open: await availability(scope),
+      requestedBy: resolveActorId(context)
+    };
+  }
+
+  return Object.freeze({ readStatus });
+}
+
+export { createBookingEngine };

package/patterns/feature-package/example/booking-engine/src/server/bookingEngineActions.js

@@ -0,0 +1,26 @@
+import { statusQueryInputValidator } from "./inputSchemas.js";
+
+const ACTION_GET_STATUS = "feature.booking-engine.status.read";
+
+/** The fields every booking query shares, spread first into each definition. */
+const BOOKING_QUERY = Object.freeze({
+  version: 1,
+  kind: "query",
+  channels: ["api", "assistant", "internal"],
+  surfaces: ["app"]
+});
+
+/** @param {{ bookingEngine: import("./types.js").BookingEngine }} dependencies */
+function createBookingEngineActions({ bookingEngine }) {
+  return Object.freeze([
+    Object.freeze({
+      ...BOOKING_QUERY,
+      id: ACTION_GET_STATUS,
+      input: statusQueryInputValidator,
+      output: null,
+      execute: (input, context) => bookingEngine.readStatus(input, { context })
+    })
+  ]);
+}
+
+export { ACTION_GET_STATUS, createBookingEngineActions };

package/patterns/feature-package/example/booking-engine/src/server/inputSchemas.js

@@ -12,8 +12,7 @@ const statusQueryInputValidator = deepFreeze({
       type: "boolean",
       required: false
     }
-  }),
-  mode: "patch"
+  })
 });
 
 export { statusQueryInputValidator };

package/patterns/feature-package/example/booking-engine/src/server/types.js

@@ -0,0 +1,12 @@
+// The types of the `feature.booking-engine` capability and of its optional
+// `feature.booking-engine.availability` slot.
+
+/** @typedef {ReturnType<typeof import("./bookingEngine.js").createBookingEngine>} BookingEngine */
+
+/**
+ * The `feature.booking-engine.availability` slot: answers whether a scope takes
+ * bookings. A package supplies it by providing that token.
+ * @typedef {(scope: string) => Promise<boolean>} BookingEngineAvailability
+ */
+
+export {};

package/patterns/feature-package/example/variations/AvailabilityEngineFeature.js

@@ -0,0 +1,19 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { createAvailabilityEngineActions } from "./availabilityEngineActions.js";
+import { createAvailabilityEngine } from "./orchestratorService.js";
+
+const AvailabilityEngineFeature = defineFeature({
+  id: "feature.availability-engine",
+  domain: "availability",
+  provides: {
+    availabilityEngine: "feature.availability-engine"
+  },
+  setup() {
+    return { availabilityEngine: createAvailabilityEngine() };
+  },
+  actions({ availabilityEngine }) {
+    return createAvailabilityEngineActions({ availabilityEngine });
+  }
+});
+
+export { AvailabilityEngineFeature };

package/patterns/feature-package/example/variations/InvoiceRollupFeature.js

@@ -0,0 +1,23 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { createInvoiceRollup } from "./customKnexRepository.js";
+import { createInvoiceRollupActions } from "./invoiceRollupActions.js";
+
+const InvoiceRollupFeature = defineFeature({
+  id: "feature.invoice-rollup",
+  domain: "invoices",
+  requires: {
+    database: "runtime.database"
+  },
+  provides: {
+    invoiceRollup: "feature.invoice-rollup"
+  },
+  /** @param {{ database: import("@jskit-ai/database-runtime/server/types").RuntimeDatabase }} capabilities */
+  setup({ database }) {
+    return { invoiceRollup: createInvoiceRollup({ knex: database.knex }) };
+  },
+  actions({ invoiceRollup }) {
+    return createInvoiceRollupActions({ invoiceRollup });
+  }
+});
+
+export { InvoiceRollupFeature };

package/patterns/feature-package/example/variations/availabilityEngineActions.js

@@ -0,0 +1,26 @@
+import { emptyInputValidator } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+
+const ACTION_GET_AVAILABILITY_STATUS = "availability.status.read";
+
+/** The fields every availability query shares, spread first into each definition. */
+const AVAILABILITY_QUERY = Object.freeze({
+  version: 1,
+  kind: "query",
+  channels: ["api", "assistant", "internal"],
+  surfaces: ["app"]
+});
+
+/** @param {{ availabilityEngine: import("./types.js").AvailabilityEngine }} dependencies */
+function createAvailabilityEngineActions({ availabilityEngine }) {
+  return Object.freeze([
+    Object.freeze({
+      ...AVAILABILITY_QUERY,
+      id: ACTION_GET_AVAILABILITY_STATUS,
+      input: emptyInputValidator,
+      output: null,
+      execute: (input) => availabilityEngine.getStatus(input)
+    })
+  ]);
+}
+
+export { ACTION_GET_AVAILABILITY_STATUS, createAvailabilityEngineActions };

package/patterns/feature-package/example/variations/customKnexRepository.js

@@ -1,34 +1,40 @@
 import { createWithTransaction } from "@jskit-ai/database-runtime/shared";
 
-function createRepository({ knex } = {}) {
-  if (!knex) {
-    throw new TypeError("createRepository requires knex.");
+/**
+ * The invoice rollup's persistence: a reviewed custom Knex repository.
+ * @param {{ knex: import("@jskit-ai/database-runtime/server/types").RuntimeKnex }} dependencies
+ */
+function createInvoiceRollup({ knex }) {
+  const withTransaction = createWithTransaction(knex);
+
+  async function getStatus(input, options = {}) {
+    return {
+      ok: true,
+      feature: "invoice-rollup",
+      persistence: "custom-knex",
+      tableName: "invoice_rollups",
+      hasTransaction: Boolean(options.trx),
+      input
+    };
+  }
+
+  async function execute(input, options = {}) {
+    return {
+      accepted: false,
+      feature: "invoice-rollup",
+      persistence: "custom-knex",
+      tableName: "invoice_rollups",
+      hasTransaction: Boolean(options.trx),
+      input,
+      message: "Replace this example with the reviewed domain-specific query."
+    };
   }
 
   return Object.freeze({
-    withTransaction: createWithTransaction(knex),
-    async getStatus(input = {}, options = {}) {
-      return {
-        ok: true,
-        feature: "invoice-rollup",
-        persistence: "custom-knex",
-        tableName: "invoice_rollups",
-        hasTransaction: Boolean(options.trx),
-        input
-      };
-    },
-    async execute(input = {}, options = {}) {
-      return {
-        accepted: false,
-        feature: "invoice-rollup",
-        persistence: "custom-knex",
-        tableName: "invoice_rollups",
-        hasTransaction: Boolean(options.trx),
-        input,
-        message: "Replace this example with the reviewed domain-specific query."
-      };
-    }
+    withTransaction,
+    getStatus,
+    execute
   });
 }
 
-export { createRepository };
+export { createInvoiceRollup };

package/patterns/feature-package/example/variations/invoiceRollupActions.js

@@ -0,0 +1,26 @@
+import { emptyInputValidator } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+
+const ACTION_GET_ROLLUP_STATUS = "invoices.rollup.status.read";
+
+/** The fields every invoice rollup query shares, spread first into each definition: they run on the admin surface. */
+const ROLLUP_QUERY = Object.freeze({
+  version: 1,
+  kind: "query",
+  channels: ["api", "assistant", "internal"],
+  surfaces: ["admin"]
+});
+
+/** @param {{ invoiceRollup: import("./types.js").InvoiceRollup }} dependencies */
+function createInvoiceRollupActions({ invoiceRollup }) {
+  return Object.freeze([
+    Object.freeze({
+      ...ROLLUP_QUERY,
+      id: ACTION_GET_ROLLUP_STATUS,
+      input: emptyInputValidator,
+      output: null,
+      execute: (input, context) => invoiceRollup.getStatus(input, { context })
+    })
+  ]);
+}
+
+export { ACTION_GET_ROLLUP_STATUS, createInvoiceRollupActions };

package/patterns/feature-package/example/variations/orchestratorService.js

@@ -1,23 +1,28 @@
-function createService() {
+/** The availability engine: orchestration with no persistence of its own. */
+function createAvailabilityEngine() {
+  async function getStatus(input) {
+    return {
+      ok: true,
+      feature: "availability-engine",
+      mode: "orchestrator",
+      input
+    };
+  }
+
+  async function execute(input) {
+    return {
+      accepted: false,
+      feature: "availability-engine",
+      mode: "orchestrator",
+      input,
+      message: "Replace this example with calls to the feature's injected collaborators."
+    };
+  }
+
   return Object.freeze({
-    async getStatus(input = {}) {
-      return {
-        ok: true,
-        feature: "availability-engine",
-        mode: "orchestrator",
-        input
-      };
-    },
-    async execute(input = {}) {
-      return {
-        accepted: false,
-        feature: "availability-engine",
-        mode: "orchestrator",
-        input,
-        message: "Replace this example with calls to the feature's injected collaborators."
-      };
-    }
+    getStatus,
+    execute
   });
 }
 
-export { createService };
+export { createAvailabilityEngine };

package/patterns/feature-package/example/variations/types.js

@@ -0,0 +1,7 @@
+// The types of the `feature.availability-engine` and `feature.invoice-rollup`
+// capabilities, for features that require them.
+
+/** @typedef {ReturnType<typeof import("./orchestratorService.js").createAvailabilityEngine>} AvailabilityEngine */
+/** @typedef {ReturnType<typeof import("./customKnexRepository.js").createInvoiceRollup>} InvoiceRollup */
+
+export {};

package/patterns/minimal-foundation/PATTERN.md

@@ -57,7 +57,34 @@ questionnaire or infer tenancy, authentication, or database requirements.
 - Treat copied files as app-owned source. Do not add provenance, ownership
   markers, receipts, ledgers, or operation-history state.
 - Keep browser dependencies aligned with the execution environment that will
-  run the tests. Vibe64 supplies its exact managed Playwright version.
+  run the tests. A managed runner supplies its exact Playwright version.
+- Server code the application adds follows
+  [typed features](https://github.com/mobily-enterprises/jskit-ai/blob/main/packages/agent-docs/site/guide/framework/typed-features.md):
+  a provided capability exports its type from `types.js`; collaborators arrive
+  through declared capabilities, typed in a JSDoc `@param` and required, never
+  probed or defaulted to nothing; slots are `optional` tokens with a named
+  default; one `create<Name>Actions({ <api> })` per feature returns frozen
+  actions whose `execute` is one call; every `create*` returns a frozen object
+  of named functions; one copy of each helper per package; files stay under
+  750 lines and functions under 600. `createServer({ runtimeEnv })` requires
+  the environment it runs with, typed as the kernel's `RuntimeEnv` (the process
+  environment, string values: `resolveRuntimeEnv()` keeps `PORT` a string), and
+  `server.js` takes `API_BASE_PATH` and `toRequestPathname` from the kernel's
+  `shared/surface/paths`. `server/lib/envFile.js` loads `.env` once per process
+  for every entry point. `server/lib/loggerOptions.js` gives Fastify's logger
+  pino's error serializer under `error` as well as `err`, so
+  `logger.error({ error }, "...")` keeps the error's message and stack. `eslint.config.mjs` holds
+  server and shared code to every typed-features rule (`typedFeaturesConfig`),
+  client code (`src/**` and `packages/*/src/client/**`, Vue components
+  included) to the client rules (`clientFeaturesConfig`), all hand-written
+  code to the size limits (`sizeLimitsConfig`), and server, config and script
+  code to the formatter (`formatterConfig`), all as errors, so `npm run lint`
+  reports code that breaks the
+  [typed features guide](https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features)
+  or the
+  [client features guide](https://mobily-enterprises.github.io/jskit-ai/guide/framework/client-features).
+  Client code the application adds keeps simple, direct code first, and types
+  each provider hook with `@jskit-ai/kernel/client/types`.
 
 ## Framework APIs
 
@@ -129,3 +156,5 @@ Confirm `/api/health` and the first product route.
 - Do not keep `reading-room` names that no longer describe the product.
 - Do not add a hidden file recording that this pattern was copied.
 - Do not turn the example into a field interpolation language.
+- Do not probe a collaborator, default one to `null`, `{}` or a no-op, fill a
+  slot with a setter after construction, or keep a module-level registry.

package/patterns/minimal-foundation/example/AGENTS.md

@@ -8,6 +8,20 @@ Framework references:
 - `https://mobily-enterprises.github.io/jskit-ai/guide/`
 - `https://mobily-enterprises.github.io/jskit-ai/patterns/`
 
+Before writing or reviewing server code (a feature, provider, action, service,
+repository, route, error or test), read the typed features guide at
+`https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features`.
+`npm run lint` checks its rules, and each finding links the section that
+explains it; `npm run verify` adds the package graph, tests and build. Fix a
+finding in the code; excuse one only with the guide's `readable-check: allow`
+comment and reason prefix.
+
+Before writing or reviewing client code (a composable, component, client
+factory or client provider), read the client features guide at
+`https://mobily-enterprises.github.io/jskit-ai/guide/framework/client-features`.
+Simple, direct code comes first: never add a layer, wrapper, registry or tiny
+module only to satisfy a rule. `npm run lint` checks its rules too.
+
 Before implementation, read the narrow relevant source pattern completely. If
 its owner package is installed, prefer that version-matched package-owned copy.
 Do not install an unrelated runtime package only to read documentation.