@niscorp/nisc 0.8.0 → 0.8.2

package/AGENTS.md

@@ -97,7 +97,7 @@ Pick per need; every piece works standalone. Nova is the only mandatory one for
 
 **Principals**
 
-10. The charter is the app's policy document: role names → glob selections over the app's universes — `actions` (which action ids exist for a principal), `data` (`table.verb` capabilities, compiled into the Vex `ScopePolicy`) and `functions` (which of the app's functions a principal's shell holds: a role with none may call none). Grant each role the functions its actions call, deliberately: moss refuses to boot and lists every call whose grants miss, for each role on its own, each combination people wear and `public`, and says where a role allows every function (`'*'`); `server.checkFunctions()`, called once the app holds the server and before it listens, builds nobody's shell once to read the functions and refuses every call to one the app does not have. The charter compiles; it never enforces and never shapes. Moss resolves it per principal and refuses to boot incoherent. Assignments (principal → roles) are app data beside it; row-level semantics the charter can't express are `behaviors`, compiled into the policy. One role name is fixed: a request with no session, and a signed-in principal with no assignment, resolve to `public`, so every charter defines it — `public: []` where it grants nothing. Boot does not check for it; without it those requests fail (`Unknown role "public"`).
+10. The charter is the app's policy document: role names → glob selections over the app's universes — `actions` (which action ids exist for a principal), `data` (`table.verb` capabilities, compiled into the Vex `ScopePolicy`) and `functions` (which of the app's functions a principal's shell holds: a role with none may call none). Grant each role the functions its actions call, deliberately: moss refuses to boot and lists every call whose grants miss, for each role on its own, each combination people wear and `public`, and says where a role allows every function (`'*'`); `server.checkFunctions()`, called once the app holds the server and has mounted every route of its own, before it listens (nobody's shell makes its reads in-process, and the server takes no route once it has answered one), builds nobody's shell once to read the functions and refuses every call to one the app does not have. The charter compiles; it never enforces and never shapes. Moss resolves it per principal and refuses to boot incoherent. Assignments (principal → roles) are app data beside it; row-level semantics the charter can't express are `behaviors`, compiled into the policy. One role name is fixed: a request with no session, and a signed-in principal with no assignment, resolve to `public`, so every charter defines it — `public: []` where it grants nothing. Boot does not check for it; without it those requests fail (`Unknown role "public"`).
 10a. The `data` universe is the INTROSPECTED database, not your schema file: it holds the engine's own tables too — moss's `integrations` (integration key hashes), `integration_actions`, `moss_generation`, `sessions` (session token hashes, under moss's credential), the `strata_ledger`, the vex cache. A role granted a data wildcard (`*.read`) denies them explicitly (`data: { allow: ['*.read'], deny: [...] }`; denies do not inherit, so every role that grants the wildcard denies). A charter check resolves against the universe boot resolves against — the app's migrations and moss's run on a scratch database, then introspected — or it proves nothing about wildcards.
 11. Per-principal UI is existence or a served variant, never a conditional. An action a principal lacks does not exist in their shell (ring 1); a different shape of the same action is a served variant (ring 2). Layouts and components never branch on roles or capability data. Ring 1 does the deriving: a canvas's `initial` takes a **candidate list** and the first id the principal actually holds mounts — members boot their home, anonymous boots the login, and nobody configures which. An ungranted candidate simply isn't there.
 11a. Per-principal boot has two hooks, and they are twins. `inputs` derives boot **data** — merged over each canvas's static seed, read from action data downstream. `seeds` derives boot **instances** — which actions to push onto which canvases, computed from the session and its own reads over the session's wire, ring-1-filtered like every other mount. A composed surface (a home, an agent's column) is `seeds` plus a `list` canvas; hand-authoring the same arrangement names it twice. Branching chrome on `inputs` is a stopgap where a served variant doesn't exist yet.
@@ -437,7 +437,7 @@ Say this out loud in the interview, because it is the part a user cannot infer:
 ## Order of work
 
 1. **The interview** (see "Before any code") — every decision answered or delegated by name, recorded in `PLAN.md` with scope, data model, and roles.
-2. **Scaffold** — manifest + runtime + terminal (moss), or boot + shell factory (degrade); canvases + empty registry; one placeholder action renders. `npm create nisc` makes exactly this — from templates that are themselves checked apps — and writes `PLAN.md` with D1 and the renderer answered and the rest open; the interview (step 1) is then about what it left open.
+2. **Scaffold** — manifest + runtime + terminal (moss), or boot + shell factory (degrade); canvases + empty registry; one placeholder action renders. `npm create nisc` makes exactly this — every app it can make is made, installed and checked by CI — and writes `PLAN.md` with D1 and the renderer answered and the rest open; the interview (step 1) is then about what it left open.
 3. **Kit** — primitives against a kitchen-sink action; lock the look before any real feature.
 4. **Data layer** — per D2/D3: schema, seed, entries, behaviors; prove one read end-to-end.
 5. **Actions** — domain by domain: list → detail → form; chrome and routes as they're needed; new action ids granted in the charter as they're minted.

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @niscorp/nisc
 
+## 0.8.2
+
+### Patch Changes
+
+- 49a4766: `npm create nisc` makes an app from items instead of four whole templates. Each answer is a folder under `templates/` — `moss` or `page`, `react` or `dom`, and the kind of app — with its files, its files for another item (`with/<item>/`), its `package.json` fragment, the keys it asks for and its lines in AGENTS.md and PLAN.md; the questions are `templates/questions.json`. The command names no item, so a new kit, shell or kind of app is a new folder, and its flag follows from it. The four apps it made before come out as they were, but for a sentence: the welcome screen no longer says which kit draws it, PLAN.md's scaffold step says "the files `npm create nisc` wrote", and AGENTS.md's line for `nisc.config.ts` is one sentence for both shells.
+
+  An item that needs keys asks for them masked, after the questions, and writes them to `.env` (`.env.example` gets the names); with no terminal they are read from the environment, never from a flag. `--workspace` keeps `workspace:^` ranges, for an app made inside the nisc repository.
+
+- 49a4766: `npm create nisc` asks who leads. **Model-first** (`--model-first`) is a moss app where a person types a message and the answer is a screen: up to six canvases, each an action opened with an input, on the areas of an arrangement (`src/app/arrangements.ts`) or a grid the model writes. One dock at the bottom holds the screens, a chip naming the answer shown with back, forward and every answer to go back to, and the line to ask in.
+
+  Jev, a fast decision model, reads the message and the open screen and says which actions likely belong; gpt-oss-120b on Groq composes the screen as a cortex agent, naming only the areas that change, and its reply is checked against the app's actions, their input schemas and the arrangements, and corrected inside the run when it does not hold. The answer streams in. What a person presses, ticks and picks stays on the screen, the model sees it, and an answer gone back to shows it as it was left. A card's link opens a screen at once; only what is typed, or a thing to ask pressed, goes to the model. Every message is recorded as a run for each model it went to, through `session.recordRun`. It asks for its keys — Groq, and TypeSafe for Jev — and writes them to `.env`.
+
+  The app starts as a tour of nisc: five screens of cards to read, and a counter, a checklist and a quick check to use, which the model can fill in too. Its AGENTS.md says how to remove the tour — a folder, a check, and edits in five files — and what to build next. The checks run the loop offline with a scripted decision model and chat model, and `src/dev/live-ask.ts` asks the real models a run of cases.
+
+  Both kits gain the components it uses — a frame, the dock, a menu, a grid and its areas, a card, code, points, steps, a checkbox, an input and the line to ask in — and a classic app has them too. The stylesheet gains their look. `src/dev/strata.ts` is each kind's own: a model-first app's also records its frame and arrangements.
+
+## 0.8.1
+
+### Patch Changes
+
+- 8eaea60: The docs say where `server.checkFunctions()` goes: after every route of the app's own, before it listens.
+
+  Nobody's shell makes its reads in-process, and the server takes no route once it has answered one: a route mounted after the check throws `Can not add a route since the matcher is already built.` moss's DOCS, nisc's AGENTS and the cli README say so.
+
+- 1a67306: `nisc start` checks the app's functions after the project's `routes` and the site are mounted.
+
+  Checking the functions answers requests in-process, and the server takes no route once it has answered one. An app with functions whose first screen reads as it mounts failed to start: `Can not add a route since the matcher is already built.`
+
+- Updated dependencies [8eaea60]
+- Updated dependencies [1a67306]
+  - @niscorp/moss@0.8.1
+  - @niscorp/cli@0.8.1
+
 ## 0.8.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niscorp/nisc",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "The nisc platform as one known-compatible set: every @niscorp package, each pinned to the exact version it was released with.",
   "license": "Apache-2.0",
   "repository": {
@@ -20,16 +20,16 @@
   },
   "dependencies": {
     "@niscorp/charter": "0.1.4",
-    "@niscorp/cli": "0.8.0",
     "@niscorp/cortex": "0.1.4",
-    "@niscorp/moss": "0.8.0",
     "@niscorp/loom": "0.5.0",
-    "@niscorp/prism": "0.3.1",
+    "@niscorp/moss": "0.8.1",
+    "@niscorp/cli": "0.8.1",
+    "@niscorp/nova": "0.5.0",
     "@niscorp/signal": "0.1.5",
+    "@niscorp/prism": "0.3.1",
     "@niscorp/solid": "0.1.2",
-    "@niscorp/tide": "0.1.7",
-    "@niscorp/nova": "0.5.0",
     "@niscorp/vex": "0.4.1",
+    "@niscorp/tide": "0.1.7",
     "@niscorp/strata": "0.1.7"
   },
   "peerDependencies": {