aw-spec-cli 0.1.26 → 0.1.27

package/assets/.appweaver/stack-profiles/go-chi.json

@@ -4,7 +4,12 @@
   "title": "Go + chi",
   "language": "Go",
   "ecosystem": "go",
-  "root": "internal/",
+  "root": "backend/",
+  "run_from": "root",
+  "conventional_root": "internal/",
+  "build_files": [
+    "go.mod"
+  ],
   "build": "go build ./...",
   "test": "go test ./...",
   "run": "go run ./cmd/api",

package/assets/.appweaver/stack-profiles/java-spring.json

@@ -4,12 +4,19 @@
   "title": "Spring Boot",
   "language": "Java",
   "ecosystem": "java",
-  "root": "src/main/java/",
-  "test_root": "src/test/java/",
+  "root": "backend/",
+  "test_root": "backend/src/test/java/",
   "run_from": "root",
-  "build": "./mvn clean install",
-  "test": "./mvn test",
-  "run": "./mvn spring-boot:run",
+  "conventional_root": "src/main/java/",
+  "conventional_test_root": "src/test/java/",
+  "build_files": [
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts"
+  ],
+  "build": "./mvnw clean install",
+  "test": "./mvnw test",
+  "run": "./mvnw spring-boot:run",
   "detect": [
     "pom.xml",
     "build.gradle"

package/assets/.appweaver/stack-profiles/nextjs.json

@@ -4,8 +4,9 @@
   "title": "Next.js",
   "language": "TypeScript",
   "ecosystem": "node",
-  "root": "web/",
+  "root": "frontend/",
   "run_from": "root",
+  "conventional_root": "web/",
   "build": "npm run build",
   "test": "npm test",
   "run": "npm run dev",

package/assets/.appweaver/stack-profiles/node-express.json

@@ -4,8 +4,14 @@
   "title": "Express + TypeScript",
   "language": "Node.js",
   "ecosystem": "node",
-  "root": "src/",
-  "test_root": "tests/",
+  "root": "backend/",
+  "test_root": "backend/tests/",
+  "run_from": "root",
+  "conventional_root": "src/",
+  "conventional_test_root": "tests/",
+  "build_files": [
+    "package.json"
+  ],
   "build": "npm run build",
   "test": "npm test",
   "run": "npm run dev",

package/assets/.appweaver/stack-profiles/python-fastapi.json

@@ -4,8 +4,15 @@
   "title": "FastAPI",
   "language": "Python",
   "ecosystem": "python",
-  "root": "app/",
-  "test_root": "tests/",
+  "root": "backend/",
+  "test_root": "backend/tests/",
+  "run_from": "root",
+  "conventional_root": "app/",
+  "conventional_test_root": "tests/",
+  "build_files": [
+    "pyproject.toml",
+    "requirements.txt"
+  ],
   "build": "python -m compileall {{root}}",
   "test": "pytest",
   "run": "uvicorn app.main:app --reload",

package/assets/.appweaver/stack-profiles/react-vite.json

@@ -4,8 +4,9 @@
   "title": "React + Vite",
   "language": "TypeScript",
   "ecosystem": "node",
-  "root": "web/",
+  "root": "frontend/",
   "run_from": "root",
+  "conventional_root": "web/",
   "build": "npm run build",
   "test": "npm test",
   "run": "npm run dev",

package/assets/.appweaver/stack-profiles/sveltekit.json

@@ -4,8 +4,9 @@
   "title": "SvelteKit",
   "language": "TypeScript",
   "ecosystem": "node",
-  "root": "web/",
+  "root": "frontend/",
   "run_from": "root",
+  "conventional_root": "web/",
   "build": "npm run build",
   "test": "npm test",
   "run": "npm run dev",

package/assets/.appweaver/stack-profiles/vue-vite.json

@@ -4,8 +4,9 @@
   "title": "Vue 3 + Vite",
   "language": "TypeScript",
   "ecosystem": "node",
-  "root": "web/",
+  "root": "frontend/",
   "run_from": "root",
+  "conventional_root": "web/",
   "build": "npm run build",
   "test": "npm test",
   "run": "npm run dev",

package/assets/.appweaver/stacks.json

@@ -1,3 +1,39 @@
 {
-  "lanes": []
+  "lanes": [],
+  "_lane_format": {
+    "lanes": [
+      {
+        "id": "service",
+        "kind": "backend",
+        "profile": "dotnet-webapi",
+        "stack": "ASP.NET Core Web API",
+        "origin": "declared",
+        "root": "backend/",
+        "test_root": "backend/tests/",
+        "run_from": "root",
+        "build": "dotnet build",
+        "test": "dotnet test",
+        "run": "dotnet run --project {{host}}",
+        "migrate": "dotnet ef database update --project {{host}}"
+      },
+      {
+        "id": "web",
+        "kind": "frontend",
+        "profile": "nextjs",
+        "stack": "Next.js",
+        "origin": "declared",
+        "root": "frontend/",
+        "test_root": "frontend/",
+        "run_from": "root",
+        "build": "npm run build",
+        "test": "npm test",
+        "run": "npm run dev",
+        "migrate": ""
+      }
+    ],
+    "prototype": {
+      "root": "prototype/",
+      "run": "npm run dev --prefix prototype"
+    }
+  }
 }

package/assets/.appweaver/templates/constitution-ui-template.md

@@ -90,9 +90,9 @@
 <!-- Form: the lane's structural mandate, named as the lane rules name it. -->
 
 [UI_STRUCTURE_CONTENT]
-<!-- Form: the lane root and the layout beneath it, as the mapped rules define it for this
+<!-- Form: the lane root folder and the layout beneath it, as the mapped rules define it for this
      lane's stack, including where generated contract clients land. This layout sits
-     ENTIRELY under the lane's root; it never adds to the service lane's structure in
+     ENTIRELY under the lane root folder; it never adds to the service lane's structure in
      constitution.technical.md. -->
 
 ## [UI_CONVENTIONS_SECTION_NAME]

package/assets/.claude/skills/appweaver/SKILL.md

@@ -1,55 +1,16 @@
 ---
 name: "appweaver"
-description: "Parametric launcher (Claude Code): run ANY converted aw-spec skill on the aw-orchestrator under one of the 4 strategies (agent [default], spawn, sdk, sdk-apply)."
-argument-hint: "<skill> [strategy] [input…] — e.g. 'select-domain', 'specify spawn Build an order API', 'analyze-slice'"
-compatibility: "Requires .appweaver/orchestrator/ and the claude CLI on PATH"
+description: "Parametric launcher: run ANY converted aw-spec skill on the aw-orchestrator under one of the 4 strategies (agent [default], spawn, sdk, sdk-apply)."
+argument-hint: "<skill> [strategy] [input…] — e.g. 'select-stack', 'specify spawn Build an order API', 'analyze-slice'"
+compatibility: "Requires .appweaver/orchestrator/ and python3"
 user-invocable: true
 disable-model-invocation: false
 ---
 
-# Orchestrator Skill Launcher
+# AppWeaver launcher
 
-Runs one converted `aw-spec-*` workflow on the shared, agent-agnostic engine. All orchestration and **all context management live in the workflow YAML + engine** (`.appweaver/orchestrator/orchestrator.py`): the interpreter assembles the COMPLETE payload (system + user) for every request; you never author generation context yourself. Execution follows the chosen strategy; the checkpoint channel carries every human-facing interaction regardless of strategy.
+Read `.appweaver/orchestrator/LAUNCHER.md` and follow it exactly.
 
-- **Engine + workflows (common, shared by all agents):** `.appweaver/orchestrator/orchestrator.py`, `.appweaver/orchestrator/workflows/aw-spec-<skill>.orch.yaml`, shared modules in `.appweaver/orchestrator/modules/`, shared scripts in `.appweaver/scripts/`
-- **This agent's transport profile:** `.claude/agent.json`
+Several agents read this folder, so this launcher names no agent: find the row for the agent you are in the profile table of `LAUNCHER.md` — that row is your transport profile. If you have no row, only the `agent` strategy is available.
 
-  > Claude Code spawns via the `claude -p` CLI (native `--system-prompt`,
-  > `--tools`, and `--bare` isolation). Its `sdk` block declares the SDK the
-  > `sdk`/`sdk-apply` strategies import (`claude-agent-sdk`) and the adapter
-  > (`.appweaver/orchestrator/adapters/claude_agent_sdk.py`, shared per-SDK)
-  > that owns its calling convention.
-
-## Execution Steps
-
-1. **Parse Arguments** (`<skill> [strategy] [input…]`):
-   - `skill` (required): the aw-spec skill name, e.g. `demo`, `select-domain`, `foundation`, `specify`, `design`, `implement`, `build`. Resolve the workflow file `.appweaver/orchestrator/workflows/aw-spec-<skill>.orch.yaml`. If it does not exist, list the available `aw-spec-*.orch.yaml` files in that folder and stop.
-   - `strategy` (optional, one of `agent`, `spawn`, `sdk`, `sdk-apply`; default `agent` — YOU fulfill each generation through the checkpoint channel, no profile needed): who executes each generation. Always pass `--strategy <strategy>`.
-   - Everything after the strategy is the user input: pass it as `--input "<text>"` (omit when empty).
-   - `--agent-profile .claude/agent.json` is required for `spawn`, `sdk`, and `sdk-apply` (`agent` needs no profile). If the SDK package isn't installed, add `--sdk-install`.
-   - **Always** pass `--checkpoint .appweaver/orchestrator/.state/<skill>.state.json` — for EVERY strategy. Converted skills contain interactive steps (questions, selections, hooks); the checkpoint is how they reach you and the user. Strategies only govern who generates.
-   - `spawn` may also add `--isolation bare|fresh` and `--model <name>`; `sdk`/`sdk-apply` accept `--model <name>`.
-
-2. **Run the Interpreter**:
-   ```bash
-   python3 .appweaver/orchestrator/orchestrator.py \
-     .appweaver/orchestrator/workflows/aw-spec-<skill>.orch.yaml \
-     --strategy <strategy> \
-     --checkpoint .appweaver/orchestrator/.state/<skill>.state.json \
-     [--agent-profile .claude/agent.json]   # spawn, sdk, sdk-apply \
-     [--input "<user input>"] \
-     --json
-   ```
-
-3. **Handle the Suspend/Resume Loop** — whenever the command exits with code `2`, read the printed `pending` JSON and dispatch on `pending.kind`; fulfill it, write the response to `pending.response_path`, then re-run the SAME command. Repeat until exit `0` (done) or `1` (stopped by a gate).
-   - **`ask`** — ask the USER the `prompt` with the listed `options` (use your question tool). Write the chosen answer as PLAIN TEXT to `response_path` (comma-separated values when `multi` is true).
-   - **`select`** — ask the USER to pick ONE of `options`; write the chosen value as plain text to `response_path`.
-   - **`hook`** — run each MANDATORY hook in `hooks` (each is a slash command of THIS agent) in this conversation; optional hooks at your discretion. Then write `done` to `response_path`.
-   - **`author`** — read `system_path` + `user_path` and treat them as your ONLY standards and context. Author the COMPLETE content of the file named in `target` and write it — content ONLY, no commentary, no code fence — to `response_path`. Do NOT write the target file yourself; the interpreter does that.
-   - **`agent_generate`** — read `system_path` + `user_path`; perform the task YOURSELF with the listed `tools` within `permission_mode`; write your full final reply — ending with the required ```json fence — to `response_path`.
-   - **`agent_query` / `agent_review`** — same as above but READ-ONLY (do not modify files); the reply must end with the required ```json fence.
-   - **`apply`** — an isolated generation already decided the changes: read `artifact_path` and write its file contents EXACTLY to the paths it names, then write the confirmation ```json fence to `response_path`.
-   - If `pending.note` is present, your previous response was rejected — follow the note and rewrite `response_path`.
-
-4. **Report**:
-   Report the final JSON (`status`, `outputs`, and any `reason`) to the user. On `stopped`, relay the gate message verbatim — it tells the user what to fix or run first.
+The arguments are the text the user typed after `/appweaver`.

package/assets/foundations/dotnet/ModularMonolith/ModularMonolith.Reference.rules.json

@@ -0,0 +1,31 @@
+{
+  "format": "aw-spec-pack-rules/v1",
+  "rules": [
+    {
+      "path": "src/AppWeaver.ModularMonolith.Infrastructure/DatabaseContext/ApplicationDbContext.cs",
+      "action": "merge",
+      "note": "The base project's DbContext has the full OnModelCreating and no DbSet<> properties; the sample's has the sample's DbSet<> properties, its own usings, and nothing else.",
+      "instruction": [
+        "Produce one ApplicationDbContext based on the EXISTING file (the base project's DbContext):",
+        "- add every using directive the INCOMING file has that the EXISTING file lacks;",
+        "- insert every INCOMING `public DbSet<...>` property, with any comment above it, as one block right after the class's opening brace (before OnModelCreating);",
+        "- keep everything else in the EXISTING file unchanged."
+      ]
+    },
+    {
+      "path": "src/AppWeaver.ModularMonolith.Domain/Interfaces/IApplicationDbContext.cs",
+      "action": "merge",
+      "note": "The base project's interface has the usings, the namespace and SaveChangesAsync; the sample's has only the sample's DbSet<> properties.",
+      "instruction": [
+        "Produce one IApplicationDbContext based on the EXISTING file (the base project's interface), keeping its using directives, its namespace and SaveChangesAsync:",
+        "- insert every INCOMING `DbSet<...>` property, with any comment above it, as one block right after the interface's opening brace (before SaveChangesAsync);",
+        "- keep everything else in the EXISTING file unchanged."
+      ]
+    },
+    {
+      "path": "src/AppWeaver.ModularMonolith.Domain/AppWeaver.ModularMonolith.Domain.csproj",
+      "action": "replace",
+      "note": "The sample ships the Domain project file too; its copy is written over the base project's."
+    }
+  ]
+}

package/assets/foundations/dotnet/VerticalSlice/VerticalSlice.Reference.rules.json

@@ -0,0 +1,16 @@
+{
+  "format": "aw-spec-pack-rules/v1",
+  "rules": [
+    {
+      "path": "src/AppWeaver.VerticalSlice.Service/Infrastructure/ApplicationDbContext.cs",
+      "action": "merge",
+      "note": "The base project's DbContext has the full OnModelCreating and no DbSet<> properties; the sample's has the sample's DbSet<> properties, its own usings, and nothing else.",
+      "instruction": [
+        "Produce one ApplicationDbContext based on the EXISTING file (the base project's DbContext):",
+        "- add every using directive the INCOMING file has that the EXISTING file lacks;",
+        "- insert every INCOMING `public DbSet<...>` property, with any comment above it, as one block right after the class's opening brace (before OnModelCreating);",
+        "- keep everything else in the EXISTING file unchanged."
+      ]
+    }
+  ]
+}

package/assets/foundations/foundation.spec.template.txt

@@ -0,0 +1,73 @@
+# kind: backend
+# profiles: dotnet-webapi
+# title: <one line shown in the /appweaver foundation pick list>
+#
+# ─────────────────────────────────────────────────────────────────────────────
+# FOUNDATION SPEC TEMPLATE — how to describe a base project for /appweaver foundation
+#
+# A spec is the alternative to a pack. A pack (<Name>.pack.txt) is a verified project
+# unpacked byte-for-byte; a spec DESCRIBES the project, and an agent builds it into the
+# lane root folder when the operator picks it. Use one where no pack ships for the
+# stack, or where the project is easier to describe than to keep as a frozen copy.
+#
+# WHERE IT GOES. Copy this file to foundations/<ecosystem>/<Name>/<Name>.spec.txt —
+# <ecosystem> is the `ecosystem` of the stack profile (.appweaver/stack-profiles/*.json:
+# dotnet, java, node, python, go …). A directory may hold a pack, specs, or both; every
+# *.spec.txt in it is its own entry, named after the file. It is listed for a lane only
+# when its header admits that lane:
+#
+#   # kind:      backend | frontend   (absent = backend)
+#   # profiles:  stack-profile ids, comma-separated (absent = any profile of that kind
+#                in the ecosystem — say which, because `node` covers Next.js, Angular,
+#                Vue, SvelteKit and the Express backend alike)
+#   # title:     the label in the pick list
+#
+# The header is the leading block of `#` lines; the first line that does not start with
+# `#` ends it. Everything after this header block is the spec itself, written for the
+# agent that builds the project — be concrete. The same shape works for a spec given at
+# the [manual spec] prompt (as a file path, or pasted as text).
+#
+# WHAT THE AGENT ALREADY KNOWS, so the spec need not repeat it: the lane root folder (the
+# WHOLE project goes inside it: build files, source and tests), its test
+# path inside that folder, and its build command, which runs in that folder (from
+# .appweaver/stacks.json), the project name the operator entered, and the technical rules
+# the selected project maps under `## /aw-spec-foundation-backend` or
+# `## /aw-spec-foundation-frontend` in its tech-rule-bindings.md. Where this spec is
+# silent the agent follows those rules; where the two disagree the spec wins and the
+# agent names the conflict. Paths below are relative to the lane root folder.
+# ─────────────────────────────────────────────────────────────────────────────
+
+# <Project kind> foundation — <stack and version>
+
+## Purpose
+One or two sentences: what this base project is for, and what it deliberately leaves out
+(business features come later from /appweaver implement).
+
+## Create
+The commands that create the project, in order, and where their output must land.
+- e.g. `dotnet new webapi -n <ProjectName> -o src/<ProjectName>.Api`
+- e.g. a solution file at the top of the lane root folder, referencing every project
+
+## Packages
+Exact packages (and versions where it matters), split by project.
+
+## Layout
+The folder structure the project starts with, as a tree. Name the folders feature code will
+later go into, even when they start empty (add a .gitkeep).
+
+## Starter files
+Each file the base project needs beyond what the tools generate — what it contains, not
+just its name: configuration, the composition root, a health endpoint, the error-handling
+middleware, a sample test that proves the test project runs.
+
+## Configuration
+Settings files, environment variables, ports, connection strings (placeholders, never
+secrets).
+
+## Tests
+The test project(s): framework, where they live (the lane's test path), and the one test that
+must pass on a fresh scaffold.
+
+## Done when
+How to confirm the scaffold works — the lane's build passes, the test command passes, the app
+starts and answers a named URL.

package/assets/foundations/java/Hexagonal/Hexagonal.pack.txt

@@ -8,7 +8,7 @@
 # --- Java foundation replacement contract ---
 #   Java content: io.appweaver -> <lowercase-app-name>
 #   Java path:    io/appweaver -> <lowercase-app-name>
-#   Application directory preserves the user-provided name.
+#   Unpacked into --out-dir as-is: that directory is the Maven module.
 # ============================================================
 
 <<<DIR path=".mvn">>>

package/assets/foundations/java/Hexagonal/unpack-foundation.sh

@@ -206,11 +206,10 @@ apply_repl() {
 
 # ----------------------------------------------------------- output root ------------
 
-if [ "$OUT_DIR" = "." ]; then
-  OUT_ROOT="$TARGET_APP_NAME"
-else
-  OUT_ROOT="$OUT_DIR/$TARGET_APP_NAME"
-fi
+# The pack is the Maven module itself (pom.xml, mvnw, src/main/java, src/test/java), and it
+# lands in --out-dir exactly as packed: that directory IS the module. The app name renames
+# the Java package; it does not add a folder.
+OUT_ROOT="$OUT_DIR"
 
 # ----------------------------------------------------------- parse pack blocks -------
 

package/assets/foundations/node/NextAppRouter/NextAppRouter.spec.txt

@@ -0,0 +1,68 @@
+# kind: frontend
+# profiles: nextjs
+# title: Next.js App Router base (TypeScript, ESLint, Vitest) built from this spec
+
+# Next.js App Router foundation — frontend lane
+
+## Purpose
+A clean, building Next.js frontend for the lane: App Router, TypeScript in strict mode,
+ESLint, a token-based design-system layer and a working test setup. No business screens —
+/appweaver implement adds those per feature later, from frontend-plan.md.
+
+## Create
+Run at the repository root, naming the lane root folder, so the app lands directly in that
+folder (not in a folder inside or beside it):
+- `npx create-next-app@latest <lane root folder without trailing slash> --typescript --eslint --app --no-src-dir --import-alias "@/*" --use-npm --no-tailwind --yes`
+Set `"name"` in package.json to the project name in lower-kebab form
+(e.g. AppWeaver.Health -> appweaver-health).
+
+## Packages
+Development dependencies:
+- vitest, @vitejs/plugin-react, jsdom
+- @testing-library/react, @testing-library/jest-dom, @testing-library/user-event
+- vitest-axe (accessibility assertions)
+
+## Layout
+Under the lane root folder (create empty folders with a .gitkeep):
+```
+app/                  App Router — layout.tsx, page.tsx, loading.tsx, error.tsx, not-found.tsx
+components/           design-system compositions, presentational only
+features/             one folder per spec feature (empty at start)
+lib/api/              the generated contract client (empty at start — never hand-written)
+lib/                  cross-feature client utilities
+locales/              locale catalogues — en.json to start
+styles/tokens.css     the semantic design tokens
+tests/                component, integration and accessibility tests
+```
+
+## Starter files
+- `styles/tokens.css` — semantic CSS custom properties only (`--color-surface`,
+  `--color-text`, `--color-muted`, `--color-danger`, `--space-1..6`, `--radius-1..3`,
+  `--font-body`), with a `prefers-color-scheme: dark` block. Imported once by
+  `app/layout.tsx`; no literal colour anywhere else.
+- `app/layout.tsx` — html `lang` from the default locale, the tokens import, a skip-to-content
+  link, `<main id="main">`.
+- `app/page.tsx` — a server component rendering the app name and one line of text.
+- `app/loading.tsx`, `app/error.tsx` (client component with a retry button), `app/not-found.tsx`.
+- `components/Button.tsx` — one presentational component styled only with tokens, as the
+  pattern later components follow.
+- `lib/env.ts` — reads `NEXT_PUBLIC_API_BASE_URL` once and exports it typed; nothing else
+  reads `process.env`.
+- `locales/en.json` — the strings the starter pages use.
+- `.env.example` — `NEXT_PUBLIC_API_BASE_URL=http://localhost:5000`.
+Remove the create-next-app demo content (the default page body, its CSS module and images).
+
+## Configuration
+- `tsconfig.json`: `"strict": true`, keep the `@/*` alias.
+- `vitest.config.ts`: jsdom environment, the React plugin, `tests/setup.ts` as setup file
+  (registers jest-dom and vitest-axe matchers), the `@/*` alias.
+- package.json scripts: `dev`, `build`, `start`, `lint` (from create-next-app), plus
+  `"test": "vitest run"` and `"typecheck": "tsc --noEmit"`.
+
+## Tests
+- `tests/page.test.tsx` — renders the home page and asserts the app name is shown.
+- `tests/button.a11y.test.tsx` — renders `Button` and asserts no axe violations.
+
+## Done when
+`npm install`, `npm run build`, `npm test` and `npm run lint` all pass in the lane root
+folder, and `npm run dev` serves the home page at http://localhost:3000.

package/assets/guardrails/README.md

@@ -13,27 +13,39 @@ guardrails/
 ├── domain/<industry>/        domain rules — vary by industry, never by stack
 │   ├── healthcare/
 │   └── pharma/
-└── projects/<project>/       what a project SELECTS
-    └── dotnet-default-project/
-        ├── tech-rule-bindings.md      → technology/dotnet-webapi/ + technology/nextjs/
-        ├── domain-rule-bindings.md    → domain/healthcare/
-        ├── service/technical-requirements.md    PROJECT-SUPPLIED
-        ├── frontend/ui-requirements.md          PROJECT-SUPPLIED
-        └── domain/domain-requirements.md        PROJECT-SUPPLIED
+├── project-specific/         the project's own rules — what it SELECTS from the corpora
+│   ├── tech-rule-bindings.md      → technology/{{backend_stack}}/ + technology/{{frontend_stack}}/
+│   ├── domain-rule-bindings.md    → domain/healthcare/
+│   ├── service/technical-requirements.md    PROJECT-SUPPLIED
+│   ├── frontend/ui-requirements.md          PROJECT-SUPPLIED
+│   └── domain/domain-requirements.md        PROJECT-SUPPLIED
+└── brf-<name>/               a project `onboard` reverse-engineers from existing code
 ```
 
-`/appweaver select-domain` selects a **project** folder and stores it in `.appweaver/domain.json`;
-`resolve-tech` and `resolve-domain` read that project's two maps. **To change what a command loads,
-edit the map — never a workflow.** The folder names `technology/` and `domain/` are the only
+**The active project is the folder `.appweaver/domain.json` names** — `project-specific` as shipped,
+and `brf-<name>` once `onboard` has run, because onboard creates that folder and writes its name
+there. No sequence selects a project. To use another one, copy `project-specific/` to a new folder
+here, change the `guardrails/project-specific/` paths inside its two maps to the new folder, and run
+the optional `/appweaver select-domain <name>` — it lists the folders here that hold a map and
+writes the one picked into `domain.json` (editing `"domain"` by hand does the same). It never
+creates a folder. Re-run `/appweaver constitution` after switching so the constitution follows.
+`resolve-tech` and `resolve-domain` read the active project's two maps. **To change what a command
+loads, edit the map — never a workflow.** The folder names `technology/` and `domain/` are the only
 vocabulary here: a project's maps may point anywhere, in any combination.
 
-**A directory under `projects/` is a project only if it carries a rule map.** Both shells'
-`list-domains` enforces that, exactly as `foundations/` requires a `*.pack.txt`. Either map
+**A directory under `guardrails/` is a project only if it carries a rule map.** Both shells'
+`list-domains` enforces that, exactly as `foundations/` requires a `*.pack.txt` or `*.spec.txt` — the
+corpora `technology/` and `domain/` carry no map, so they are never taken for a project. Either map
 qualifies, because `onboard` writes the domain map several steps before the technical one.
 
-**A brownfield project owns its rules outright.** `dotnet-default-project` above holds only three
+**The technical map names no stack.** Every path in `project-specific/tech-rule-bindings.md` writes
+its stack directory as `{{backend_stack}}` or `{{frontend_stack}}`, resolved from the lanes in
+`.appweaver/stacks.json`, so the same map serves a .NET repo and a Spring one. A corpus that lacks a
+mapped file reports it as missing and loads nothing in its place.
+
+**A brownfield project owns its rules outright.** `project-specific/` above holds only three
 files because it maps the rest from the shared corpora. A project `onboard` reverse-engineers —
-`projects/brf-<name>/` — holds everything: the domain set in `domain/`, the technical set in
+`brf-<name>/` — holds everything: the domain set in `domain/`, the technical set in
 `service/`, the lane set in `frontend/`, and its own charter at `domain/domain-constitution.md`,
 named the way an industry corpus names its charter. Both maps still sit at the project root, and
 nothing a project owns is written outside its own folder — which is what lets two onboarded
@@ -91,7 +103,7 @@ is what lists it. Infer the tier from the folder and the fold breaks.
   `stacks.json` and a rule folder are the same word.
 - **An industry** — create `domain/<industry>/`, author the overlays, point a project's
   `domain-rule-bindings.md` at it. The technical map needs no edit.
-- **A project** — copy `projects/dotnet-default-project/`, repoint the bullets, replace the three
+- **A project** — fill in `project-specific/`: repoint the bullets and replace the three
   project-supplied files. Nothing outside that folder changes.
 
 ## Files — technical (`technology/dotnet-webapi/`)
@@ -214,8 +226,10 @@ Everything this tree once held that governance does not load left it on 2026-08-
 `foundations/<stack>/`:
 
 - **Scaffold corpora** — `foundations/dotnet/ModularMonolith/` and `foundations/dotnet/VerticalSlice/`:
-  a `<Name>.pack.txt` payload and the scripts that pack and unpack it, read by
-  `/appweaver foundation`.
+  a `<Name>.pack.txt` payload and the scripts that pack and unpack it; and specs —
+  `foundations/node/NextAppRouter/NextAppRouter.spec.txt` — that describe a project an agent
+  builds into the lane. Both read by `/appweaver foundation`; the shape of a spec is
+  `foundations/foundation.spec.template.txt`.
 - **Framework component runbooks** — `foundations/dotnet/components/`: the integration contracts
   `/appweaver add-component` follows when wiring an opt-in component into a scaffolded project.
 

package/assets/guardrails/{projects/dotnet-default-project → project-specific}/domain-rule-bindings.md

@@ -1,4 +1,4 @@
-# dotnet-default-project — Command → Domain-Rule-File Map
+# project-specific — Command → Domain-Rule-File Map
 
 Per-command list of the **domain** rule files this project loads (via `resolve-domain`
 + the `domain-select` module, into the sticky standards set) for the spec-anchored
@@ -19,8 +19,8 @@ through the spec/design (as CN-/DC-/IC- ids).
 - To govern a different industry, repoint these bullets at another
   `guardrails/domain/<industry>/` corpus — `guardrails/domain/pharma/` also ships. Nothing
   else changes: the technical map, the workflows and the engine are untouched.
-- This file is the **canonical domain mapping** for this project; `/appweaver
-  select-domain` selects this project folder as active.
+- This file is the **canonical domain mapping** for this project; it is used whenever
+  `.appweaver/domain.json` names `project-specific`, which it does by default.
 
 ---
 
@@ -49,12 +49,12 @@ through the spec/design (as CN-/DC-/IC- ids).
 - guardrails/domain/healthcare/zero-trust.domain.md
 - guardrails/domain/healthcare/ai-rules.domain.md
 - guardrails/domain/healthcare/folder-structure.domain.md
-- guardrails/projects/dotnet-default-project/domain/domain-requirements.md
+- guardrails/project-specific/domain/domain-requirements.md
 
 ## /aw-spec-specify
 <!-- The FULL domain set. Specify models the domain COMPLETELY and LIFTS the constraint
      overlays into the spec's CN-/DC-/IC- sections (design/implement never see these files). -->
-- guardrails/projects/dotnet-default-project/domain/domain-requirements.md
+- guardrails/project-specific/domain/domain-requirements.md
 - guardrails/domain/healthcare/domain-driven-design.domain.md
 - guardrails/domain/healthcare/clinical-terms.md
 - guardrails/domain/healthcare/terminology.md