arkgate 4.8.13 → 4.8.15

package/templates/arkrules/DomainModel.json

@@ -28,5 +28,18 @@
       "description": "Prefer rich domain types over data-only bags (advisory only)."
     }
   ],
-  "invariants": []
+  "invariants": [
+    {
+      "id": "INV-ALWAYS-VALID",
+      "description": "A domain object is never stored in an invalid state",
+      "mode": "advisory",
+      "coverage": { "test": false }
+    },
+    {
+      "id": "INV-ONE-DECISION",
+      "description": "Each business fact has one place that decides it",
+      "mode": "advisory",
+      "coverage": { "test": false }
+    }
+  ]
 }

package/templates/skills/ark-adopt.md

@@ -5,6 +5,10 @@ description: Session 0 — write the rules file (ark.config.json) to match the r
 
 # /ark-adopt — Mark the path (session 0)
 
+**Contener · Guiar · Ordenar.** In plain words: contain the write, guide the next
+step, order leftover mess. This door is **Contener**: write the path so the tree
+has honest houses. Skills never enforce — CLI / hooks / CI do.
+
 **When:** empty tree, or the rules file does not match the real folders (session 0).
 **Not when:** a single new file (`/ark-place`) or leftover design after the path is honest (`/ark-explore` then `/ark-autopilot`).
 
@@ -17,11 +21,33 @@ description: Session 0 — write the rules file (ark.config.json) to match the r
 ## Checklist
 
 - Existing tree: propose **SharedKernel** (types/constants) + **CompositionRoot** (wiring) + `src/**/domain/**`. Never dump bare `src/lib/**` into Application.
+- Every `include` path must land in a layer. Include that classifies no file is the
+  same as an empty check — not a pass. Fix globs here; do not leave a loose gap.
 - Generate `.ark/golden-pattern.json` (load-bearing for `/ark-place`).
 - Future houses: mark unused layer globs `reserved` / `allowEmpty` so `--strict-config` does not fail.
 - When the product map or glossary names a house, write `layers[].description` as
   app-context copy (what this folder is *in the product*). Compact starter may omit.
   Do not invent captions. Do not invent `/ark-describe`.
+- When the product map names who a folder is for, write `layers[].trustBoundary`
+  (`public` | `auth` | `admin` | `internal`). Compact starter may omit. Do not
+  invent tags. Absence is silent. No `/ark-trust`.
+- When the product map names who owns a folder, write `layers[].owners`
+  (GitHub handle or email). Compact starter may omit. Do not invent people.
+  Absence is silent unless the user asked for required owners — then write
+  `requireLayerOwners: true` after the live houses have names. No `/ark-owners`.
+- When the user wants required gates (`--require-gates` / `--strict-merge` /
+  required GitHub check) and there is no `docs/adr/` (or `docs/decisions/`),
+  leave a short decision note there — only if they loosen a rule or add a real
+  gate. Not every change. Doctor residual is soft. No `/ark-adr`.
+- When a product-domain doc is already in play (`docs/domain.md` or a sibling)
+  and doctor JSON has `statesTransitions` or `statusTransitionCatalog`, add a
+  short states → transitions table (or one link) there. Use catalog names when
+  present. No flag soup. Soft residual. Silent when that doc is absent or
+  Domain has no status vocabulary. No `/ark-states`.
+- When doctor JSON has `noDomainFrontend`, keep the empty Domain house — do not
+  delete it to “clean” empty layers. Next is one Domain file (`/ark-place`), not
+  a weaker contract. Soft. Silent when there is no frontend or Domain already
+  has files. No `/ark-domain`.
 - CLI-first: if `arkgate-check` already resolved the root, do not wait on MCP.
 - Do not add `arkRun` or `arkOrder` unless the user wants that extra. When they do, write
   **advisory** extra in this turn (`arkRun` schema `1.2+`; `arkOrder` schema `1.3+`).
@@ -102,6 +128,46 @@ received."), not architecture jargon. Compact starter / `ark start` may omit the
 field. Absence is silent — never fail `--strict-config` for a missing caption.
 Do **not** invent captions. Do not invent `/ark-describe`.
 
+## Layer trust (process)
+
+Optional `layers[].trustBoundary`: `public` | `auth` | `admin` | `internal`.
+Marks who this folder is for (anyone, signed-in users, operators, or only
+other code). Write it when the product map already names that door. Compact
+starter / `ark start` may omit it. Absence is silent — never fail
+`--strict-config`, never invent a doctor residual. Do **not** invent tags.
+This is not host/CI TLS and does not add import-rule teeth. No `/ark-trust`.
+
+## Layer owners (process)
+
+Optional `layers[].owners`: GitHub handles or emails (same identity as
+`stewards` — not a display name). Write them when the product map already
+names who owns the house. Compact starter / `ark start` may omit. Absence is
+silent unless the user asked for required owners. Then write
+`requireLayerOwners: true` only after every live (non-reserved) layer has
+at least one owner. Do **not** invent people. No `/ark-owners`. The require
+flag is the fail-closed switch; owners themselves are metadata.
+
+## Decision notes (process)
+
+When gates are required (`--require-gates` / `--strict-merge` / required merge
+status) and there is no short decision-note home yet, doctor may ask for one
+under `docs/adr/` or `docs/decisions/`. Write a note when you loosen a rule or
+add a real gate — not on every file. Absence is silent unless that demand is
+on. The hint does not fail the check. Do **not** invent `/ark-adr`. Policy
+weaken still uses `--policy-ack`; this is only a place to write the why.
+
+## States and transitions (process)
+
+When a product-domain / domain-model doc is already on disk (`docs/domain.md`,
+`docs/data-model.md`, or a dedicated `docs/states.md`) and there is no short
+states → transitions table (or one link), doctor may ask for one. Write the
+table on that home — entity · states · allowed from → to. Names from the
+code or the captain. When doctor JSON has `statusTransitionCatalog`, use those
+entity · states names — Domain already opted in by having that vocabulary.
+Do **not** invent states or flag soup. Absence of the domain doc, or Domain
+with no status union/enum, stays silent. The hint does not fail the check.
+Do **not** invent `/ark-states`. Do not walk the tree to invent a roster.
+
 ## When / not when
 
 | Use `/ark-adopt` when… | Do **not** use it when… |
@@ -111,7 +177,7 @@ Do **not** invent captions. Do not invent `/ark-describe`.
 | Mine loose business rules into Domain / advisory ArkRules | Apply leftover design after the path is honest → `/ark-autopilot` |
 | Freeze **real** debt after the config is honest | User said map only |
 | Turn **advisory** ArkRun on (`arkRun` extra, schema `1.2+`; **`kernelRoots` preferred**) | Evaluate / wire a hand-rolled bus → `/ark-runtime`; new kernel-managed file → `/ark-place` |
-| Turn **advisory** ArkOrder on (`arkOrder` extra, schema `1.3+`, `planeRoots`) | New plane-root file after extra is on → `/ark-place`; grind skip clusters → `/ark-autopilot` |
+| Turn **advisory** ArkOrder on (`arkOrder` extra, schema `1.3+`, `planeRoots`) | Wire one plane candidate after extra is on → `/ark-order`; new plane-root file → `/ark-place`; grind skip clusters → `/ark-autopilot` |
 
 ## Dual engine (mandatory)
 
@@ -147,14 +213,15 @@ ArkGate has **always-on Layers** plus opt-in extras. The user chooses extras; yo
 2. Never call an import-edge violation an “invariant” or an aggregate sensor a “layer deny.”
 3. Absence of `arkRules` is **valid** — do not force ArkRules unless the user wants them or residual inventory clearly wants a pilot.
 4. Editing `arkrules/*` or promoting modes is **this skill** (session 0) or **`/ark-autopilot`** later; never invent `mechanical-safe`.
-5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
+5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` / `INVARIANT_CATALOG_EMPTY` with `evidence.arkruleId`.
 6. Absence of `arkRun` is **valid**. Write it only when the user wants the extra. Skills never enforce.
-7. Absence of `arkOrder` is **valid**. Write it only when the user wants the extra. Do not invent `/ark-order`. Skills never enforce.
+7. Absence of `arkOrder` is **valid**. Write it only when the user wants the extra. After the extra is honest: handoff **`/ark-order`** to wire one candidate. Skills never enforce.
 
 
 ### Adopt + ArkRules
 - After classify: emit or refresh `arkRules` for matched layers (exact names; generic mold for unknowns).
 - Mine rules → inventory + write advisory invariants/structure into `arkrules/<Layer>.json` **in this turn**.
+- Empty `invariants[]` on a populated Domain while `arkRules` is on is residual (`INVARIANT_CATALOG_EMPTY`), not done. Fill 1–2 short phrases. Advisory until a domain structure rule is `enforced`.
 - Application / Features templates include advisory `writes-via-aggregate`: driver import + write token in a use case is the skip. Do not copy `Externals/` / `admission.ts` folder religion.
 - Freeze baseline is **[Layer]** debt; inventory residual is **[ArkRules]** — report both.
 
@@ -191,9 +258,9 @@ ArkGate has **always-on Layers** plus opt-in extras. The user chooses extras; yo
 - A use-case that `prisma.*.update({ plan })` while `plan` is in `xiKeys` is **[ArkOrder]** `ARKORDER_XI_FIELD_WRITE`. Invoices and seats still flow through `ingest`.
 
 - Do **not** put `arkOrder` on the compact starter / `ark start` scaffold. Domain stays plane-free. Import `createOrderPlane` from `arkgate/order` (same npm package).
-- Absence is valid and **silent** — never force the extra. Do not invent `/ark-order`.
+- Absence is valid and **silent** — never force the extra.
 - Demoting enforced → advisory or deleting the extra is policy-delta **weakening**.
-- After the extra is honest: handoff `/ark-place` for new plane-root files; grind skip via `/ark-autopilot`. Skills never enforce.
+- After the extra is honest: handoff **`/ark-order`** to wire one candidate, `/ark-place` for new plane-root files; grind skip via `/ark-autopilot`. Skills never enforce.
 
 ## Subagent fan-out (optional, host-dependent)
 
@@ -218,6 +285,9 @@ feature dirs, plan clusters), you **may** dispatch **subagents**:
 - **Brownfield:** this skill — match config to reality; do not force a starter preset.
 - **Deep map only:** `/ark-explore`.
 - **Default path:** `ark start` → **`/ark-adopt`** → `/ark-place` / `/ark-autopilot`.
+  `start --apply` may refuse (coverage below 50% or weak shape) — that lock is
+  deliberate. Lock the shape with `--archetype`, `--preset`, or `--force`, or
+  inspect ranked shapes with `ark-check --recommend`.
 
 ## Anti-wrapper rule (mandatory)
 
@@ -244,6 +314,9 @@ Ark protects the **boundary around** a framework, not its internals. Nest/DI pub
    If `src/contexts` or `src/bounded-contexts` exists, prefer `ddd-bounded-contexts`.
    **Next.js:** `app/api/**` / `pages/api/**` (and route-group `app/(…)/api/**`) default to
    **ApplicationOrchestration**, not Presentation — do not reclassify API shells as UI.
+   Write Next-flavored `layers[].description` only when Next is actually present
+   (`next` dependency, `next.config.*`, or `app/page` / `pages/*` routes). Library and
+   package monorepos keep framework-free captions — `ark start` already does this.
    User wants the ArkRun extra → write **advisory** `arkRun` (schema `1.2+`, real
    `kernelRoots` preferred — `compositionRoots` alias, existing `managedLayers`) **in this turn**.
    User wants the ArkOrder extra → write **advisory** `arkOrder` (schema `1.3+`, real
@@ -251,6 +324,12 @@ Ark protects the **boundary around** a framework, not its internals. Nest/DI pub
    to a compact starter. Do not promote to enforced as the session-0 default.
    When the product map or glossary names a house, write `layers[].description` on that
    layer (app-context sentence). Compact starter may omit. Do not invent captions.
+   When the product map names who a folder is for, write `layers[].trustBoundary`
+   (`public` | `auth` | `admin` | `internal`). Do not invent tags.
+   When the product map names who owns a folder, write `layers[].owners`
+   (GitHub handle or email). Do not invent people. Write `requireLayerOwners`
+   only when the user asked for required owners and the live houses already
+   have names.
 2. **Check + diagnose** — `summary.concentrated` / dominant edge → fix contract first, don’t freeze.
    Cross-slice / cross-context `peerIsolation` hits are judgment: extract shared or events.
    The denial names its reason. `unclassifiable path` in bulk means shared code lives outside
@@ -264,6 +343,8 @@ Ark protects the **boundary around** a framework, not its internals. Nest/DI pub
 3. **Classify ungoverned** — use coverage `suggestions` **plus** dirs you discovered by reading;
    add layers/patterns **here** (write `ark.config.json`). When adding a layer the product map
    or glossary already names, write `layers[].description` on it (do not invent filler).
+   Write `layers[].trustBoundary` only when the product map already names that door.
+   Write `layers[].owners` only when the product map already names who owns the house.
 4. **Mine business rules → manifiesto** (model job — this is why the skill exists):
    - Scan for loose domain: validators, pricing/policy functions, `can*`/`calculate*`, magic business constants, publish/intent strings, logic in UI/hooks that belongs in Domain.
    - **ArkRules inventory (AR13):** run `ark-check --rules-inventory --json` for deterministic candidates
@@ -301,8 +382,12 @@ proposals applied or deferred, **phase**, **top Shape / design-weak opportunitie
 - Force runtime kernel over existing Nest/DI.
 - Put `arkRun` or `arkOrder` on the compact starter / `ark start` scaffold.
 - Claim in-memory kernel stores are production durability.
-- Invent `/ark-run` or `/ark-order`.
+- Invent `/ark-run`. Use `/ark-order` after this door turns the extra on.
 - Invent `layers[].description` filler or a `/ark-describe` skill.
+- Invent `layers[].trustBoundary` tags or a `/ark-trust` skill.
+- Invent `layers[].owners` names or a `/ark-owners` skill.
+- Invent `/ark-adr` or require a decision note on every change.
+- Invent `/ark-states` or invent entity states / flag soup.
 - Claim Enforce while governed% is low, cores empty with I/O in Application, or core bags ungoverned.
 - End adopt with only “baseline written” when design-weak residual is visible in files you opened.
 

package/templates/skills/ark-architect.md

@@ -5,13 +5,8 @@ description: Shortcut to /ark-adopt for a new tree. Deprecated as a first-class
 
 # /ark-architect — Shortcut to /ark-adopt
 
-**Not a first-run door.** This leftover name is a shortcut. Session 0 is **`/ark-adopt`**.
-Do that job now. Do not send the user to `/ark-contract` or `/ark-fix`.
-
-## Autonomy contract
-
-Invoking this skill **is** the approval to mark the path. Write `ark.config.json` and
-phase-1 dirs in this turn. Then `ark-check`.
+**Not a first-class door.** One-release redirect. Session 0 is **`/ark-adopt`**.
+Do that job now. Contener · Guiar · Ordenar — this leftover name is not a star.
 
 ## When / not when
 
@@ -40,25 +35,17 @@ restart/retargeting is required. `ark://manifest` never satisfies this preflight
 
 Then call **`ark_recommend`** with the same bound `project` envelope (or `ark-check --recommend`).
 
-## Dual plane — layers + extras (mandatory, except /ark-runtime)
-
-Label findings **`[Layer]`** vs **`[ArkRules]`** vs **`[ArkRun]`** vs **`[ArkOrder]`**. Absence of extras is valid and silent. Session-0 extras (advisory `arkRun` / advisory `arkOrder`) live on **`/ark-adopt`**. When ArkOrder is on: first freeze `release()`, later ξ is `proposeRelease` then `apply`; `refreshSigma`; ingest residual `absorb | escalate_up | hold`; capacity pack as data; in-memory `ReleaseStore`; ArkRun `decisionTape`. Do not invent `/ark-run` or `/ark-order`. Skills never enforce.
-
 ## Subagent fan-out (optional, host-dependent)
 
 If the host supports **parallel subagents**, fan out read-only scouts; otherwise
 **fall back to sequential**. Never weaken the gate.
 
-## Related onboarding
-
-- **Greenfield:** this shortcut → **`/ark-adopt`** + `ark-check --recommend` / `ark start`.
-- **Brownfield:** `/ark-adopt` — do not force a starter preset.
-
 ## Steps
 
 1. Bind MCP (`ark_identity` then `ark_recommend`) or run `ark-check --recommend`.
-2. Execute **`/ark-adopt`** autonomy: write the config, dirs, optional advisory ArkRules, optional advisory ArkRun / ArkOrder when asked, gates.
-3. `ark-check --strict-config`. Handoff `/ark-place` for new files.
+2. Execute **`/ark-adopt`** now (write the path, optional advisory extras).
+3. New file → `/ark-place`. Map → `/ark-explore`. Apply → `/ark-autopilot`.
+   Wire ArkRun → `/ark-runtime`. Wire ArkOrder → `/ark-order`.
 
 ## Completion contract (skill incomplete if missing)
 

package/templates/skills/ark-autopilot.md

@@ -5,6 +5,10 @@ description: Fix illegal imports and one leftover-design refactor. CLI is a sens
 
 # /ark-autopilot — Apply the path
 
+**Contener · Guiar · Ordenar.** In plain words: contain the write, guide the next
+step, order leftover mess. This door is **Guiar**: apply leftover design and illegal
+imports, one small change at a time. Skills never enforce — CLI / hooks / CI do.
+
 **When:** the user wants architecture cleaned end-to-end, or leftover design after a map.
 **Not when:** map only (`/ark-explore`), session 0 / config lying (`/ark-adopt`), or one new file (`/ark-place`).
 
@@ -12,6 +16,8 @@ description: Fix illegal imports and one leftover-design refactor. CLI is a sens
 
 1. Read `arkgate-check --doctor` (do #1).
 2. Fix import-rule debt; if leftover design remains, apply **one** small refactor.
+   When doctor JSON has `noDomainFrontend`, that refactor is one pure rule into
+   Domain — not another UI helper. Soft. Silent when Domain already has files.
 3. Re-run doctor. Never weaken `ark.config.json`.
 
 **This is the apply door.** Invoking it **is** the approval. Run `arkgate-check --doctor` for the next step.
@@ -28,7 +34,9 @@ Apply plan A (`mechanical-safe` **and** judgment). If leftover design work remai
 Composes **explore → sensors → dual plan → write**. Validate with ark-check; never weaken the gate.
 **Team lock:** do not edit `ark.config.json`, `arkrules/*`, or `.ark-baseline.json` in this
 turn unless the user invoked a steward contract session. Feature diffs use
-`ark-check --changed --base <merge-ref>`. Growing the baseline is steward-only.
+`ark-check --local --base <merge-ref>` or `ark-check --changed --base <merge-ref>`.
+`--local` is the optional cheap path for many worktrees; it cannot combine with
+`--strict-merge`. Growing the baseline is steward-only.
 
 **Not a plan grinder.** Empty `--plan` does **not** mean “architecture is healthy” without
 the explore pass and dual-plan section B (pattern / Shape bets).
@@ -60,7 +68,7 @@ patterns are **out-of-scope** lenses — say so; do not invent Ark enforcement f
 | Brownfield or greenfield with apply | Session 0 / config lying → `/ark-adopt` first, then return |
 | User wants A + B planned and **applied** | New file only → `/ark-place` |
 | **Apply** leftover design (one Shape refactor) | User said map only |
-| Extra skip cluster (`ARKRUN_*` / `ARKORDER_*`) after extra is on | Extra off → `/ark-adopt` (advisory); evaluate one bus → `/ark-runtime` |
+| Extra skip cluster (`ARKRUN_*` / `ARKORDER_*`) after extra is on | Extra off → `/ark-adopt` (advisory); evaluate one bus → `/ark-runtime`; evaluate one order-plane candidate → `/ark-order` |
 | Spaghetti under ENFORCE: Shape work (invoke = apply one pilot) | — |
 
 **Post-green door:** `/ark-explore` shape-focus → dual-plan B, **then this skill applies one
@@ -127,8 +135,8 @@ ArkGate has **always-on Layers** plus opt-in extras. The user chooses extras; yo
 2. Never call an import-edge violation an “invariant” or an aggregate sensor a “layer deny.”
 3. Absence of `arkRules` is **valid** — do not force ArkRules unless the user wants them or residual inventory clearly wants a pilot.
 4. Editing `arkrules/*` or promoting modes and fixing structure sensors is **this skill** (judgment, never invent `mechanical-safe`).
-5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
-6. Absence of extras is **valid**. Extra skip clusters grind **here** after the extra is on. Do not invent `/ark-run` or `/ark-order`. Skills never enforce.
+5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` / `INVARIANT_CATALOG_EMPTY` with `evidence.arkruleId`.
+6. Absence of extras is **valid**. Extra skip clusters grind **here** after the extra is on. Evaluate one bus → `/ark-runtime`; evaluate one order-plane candidate → `/ark-order`. Do not invent `/ark-run`. Skills never enforce.
 
 
 ### Autopilot + ArkRules
@@ -148,7 +156,7 @@ When `arkRun` is present:
 ### Autopilot + ArkOrder
 When `arkOrder` is present:
 - Grind skip clusters with judgment: `ARKORDER_MISSING_PLANE` / `ARKORDER_KERNEL_IN_DOMAIN` / `ARKORDER_GENERIC_UPDATE` / `ARKORDER_TOO_MANY_PARAMS` / `ARKORDER_INGEST_WRITES_XI` / `ARKORDER_XI_FIELD_WRITE` / `ARKORDER_UNVALVED_RELEASE`. First freeze with `release()`; later ξ change is `proposeRelease` then `apply`. `refreshSigma`; ingest residual `absorb | escalate_up | hold` + `reasonCode`; capacity pack; `createMemoryReleaseStore`; `ingestTravelAction`; ArkRun `decisionTape`. Never `update`/`patch`/`set`. Name `xiKeys`; do not persist those keys from a use-case. Do not “fix” a derived status by adding it to `xiKeys`; that institutionalizes the skip, so derive it on read or fold it from ingest. Doctor / status `arkOrder` is `notAScore`.
-- Extra off → `/ark-adopt` (advisory). Do not invent `/ark-order`.
+- Extra off → `/ark-adopt` (advisory). Wire one candidate → `/ark-order`.
 - Skills never enforce.
 
 ## Subagent fan-out (optional, host-dependent)
@@ -266,7 +274,7 @@ Status lights from doctor — not settings you choose. Rank residual honestly:
 - Claim ENFORCE / “done” when doctor reports `contract-false-green-io-under-application` (adopt first).
 - Claim “done” solely because plan A is empty while explore/B residual remains unlisted.
 - Replace host Nest/DI with the runtime kernel unasked.
-- Invent `/ark-run` or `/ark-order`.
+- Invent `/ark-run`. Use `/ark-order` to wire one plane candidate.
 - Auto-apply pattern (B) bets as if they were mechanical-safe.
 - Create origin only after a long cleanup (freezes a polished “before” that never was).
 

package/templates/skills/ark-contract.md

@@ -5,21 +5,18 @@ description: Shortcut — edit the rules file or extra rules. Use /ark-adopt or
 
 # /ark-contract — Shortcut to adopt / autopilot
 
-**Not a first-run door.** This leftover name is a shortcut. Writing `ark.config.json` is
+**Not a first-class door.** One-release redirect. Writing `ark.config.json` is
 **`/ark-adopt`** at session 0 and **`/ark-autopilot`** afterward. Do that job now.
-
-## Autonomy contract
-
-Invoking this leftover name **is** the approval to write an honest config. Do not
-preview-only. Never weaken the architecture config.
+Contener · Guiar · Ordenar — this leftover name is not a star.
 
 ## When / not when
 
 | Use this leftover name when… | Prefer instead |
 |------------------------------|----------------|
-| Layers / include / ArkRules / **ArkRun extra** / **ArkOrder extra** need an edit | **`/ark-adopt`** (path, first `arkRun` / first `arkOrder`) or **`/ark-autopilot`** (tighten) |
+| Layers / include / ArkRules / first extra need an edit | **`/ark-adopt`** (path, first `arkRun` / first `arkOrder`) or **`/ark-autopilot`** (tighten) |
 | False-green / concentrated edge | **`/ark-adopt`** — write the honest config |
-| Kernel extra / one kernel candidate | **`/ark-runtime`** — leftover name; wires `arkgate/runtime`, not a second package |
+| One kernel candidate | **`/ark-runtime`** |
+| One order-plane candidate | **`/ark-order`** |
 
 ## Dual engine (mandatory)
 
@@ -39,14 +36,6 @@ retain `projectIdentity.projectId`, then pass both `expectedRoot` and `expectedP
 uncertain, do not consume MCP analysis: use the workspace-local CLI and report that MCP
 restart/retargeting is required. `ark://manifest` never satisfies this preflight.
 
-## Dual plane — layers + extras (mandatory, except /ark-runtime)
-
-Label findings **`[Layer]`** vs **`[ArkRules]`** vs **`[ArkRun]`** vs **`[ArkOrder]`**. Absence of extras is valid and silent. First-time extra is **`/ark-adopt`** (advisory). Wire one kernel candidate with **`/ark-runtime`**. New kernel-managed / plane-root file with **`/ark-place`**. Grind skip clusters with **`/ark-autopilot`**. Do not invent `/ark-run` or `/ark-order`. Skills never enforce.
-
-Application / Features may declare advisory **`writes-via-aggregate`**: a use-case that imports a persistence driver and calls `.insert` / `.create` / `INSERT INTO` is the skip. Persistence adapters stay the write edge. Do not add `Externals/` or `admission.ts` as contract law.
-
-When `arkOrder` is on, name **`xiKeys`** (3–5 slow product decisions). Membership ids and recomputable statuses are not keys: derive a status on read or fold it from ingest instead. A use-case that persists those keys is `ARKORDER_XI_FIELD_WRITE`. First freeze is `release()`; later ξ is `proposeRelease` then `apply`; `refreshSigma`; ingest residual `absorb | escalate_up | hold` + `reasonCode`; capacity pack as data; in-memory `ReleaseStore`; ArkRun `decisionTape`. The billing gallery lives on GitHub, not in the npm tarball: [examples/arkorder-billing](https://github.com/pedroknigge/arkgate/tree/main/examples/arkorder-billing). Rename the three keys. The check remains silent on semantic entailment.
-
 ## Subagent fan-out (optional, host-dependent)
 
 If the host supports **parallel subagents**, fan out read-only scouts; otherwise
@@ -59,9 +48,9 @@ If the host supports **parallel subagents**, fan out read-only scouts; otherwise
 
 ## Steps
 
-1. If the path is missing or lying → execute **`/ark-adopt`** (including first advisory `arkRun` / first advisory `arkOrder`).
-2. If the path is honest and you are tightening rules or extras (`arkRun` / `arkOrder`) → execute **`/ark-autopilot`**.
-3. One kernel candidate (extra already on) → **`/ark-runtime`**. `ark-check --strict-config`.
+1. Path missing or lying → execute **`/ark-adopt`** (including first advisory `arkRun` / first advisory `arkOrder`).
+2. Path honest and tightening → execute **`/ark-autopilot`**.
+3. One kernel candidate → **`/ark-runtime`**. One order-plane candidate → **`/ark-order`**.
 
 ## Completion contract (skill incomplete if missing)
 
@@ -73,5 +62,5 @@ Skill incomplete if missing any field below.
 - **Result:** one-line outcome
 - **Planes:** one-line split of residual **[Layer]** vs **[ArkRules]** vs **[ArkRun]** vs **[ArkOrder]** (or `n/a` if unused)
 - **Compass:** top residual lenses | `n/a`
-- **Handoff:** `/ark-adopt` / `/ark-autopilot` / `none`
+- **Handoff:** `/ark-adopt` / `/ark-autopilot` / `/ark-order` / `none`
 - **Incomplete?** `no` | `yes — <what is missing>`

package/templates/skills/ark-coverage.md

@@ -5,9 +5,13 @@ description: How much of the tree the rules file covers. CLI is a sensor; read t
 
 # /ark-coverage — Ark adoption fitness (not full recon)
 
+**Contener · Guiar · Ordenar.** In plain words: contain the write, guide the next
+step, order leftover mess. This door is **Guiar**: adoption fitness numbers, not a full map.
+Skills never enforce — CLI / hooks / CI do.
+
 **Not a first-run door.** Fitness numbers only (governed files, gates, baseline).
 Session 0 → **`/ark-adopt`**. Leftover design → **`/ark-explore`**. Apply → **`/ark-autopilot`**.
-Do not send the user to leftover `/ark-contract` or `/ark-fix`.
+Wire ArkRun → **`/ark-runtime`**. Wire ArkOrder → **`/ark-order`**.
 
 You audit **how this repo uses ArkGate** (coverage, gates, baseline, host write path) and
 what adoption gaps remain. Work autonomously. End with a ranked fitness report.
@@ -41,7 +45,7 @@ patterns are **out-of-scope** lenses — say so; do not invent Ark enforcement f
 | “How adopted is Ark?” governed%, gates, baseline, skills stale | Full product map / what-next architecture → `/ark-explore` |
 | Capability gaps (CI, write path, ESLint, optional layers) | Apply fixes end-to-end → `/ark-autopilot` |
 | Ranked *adoption* opportunities (install, ratchet, contract classify) | Spaghetti pattern plan / golden pattern → `/ark-explore` dual-plan seed |
-| Quick honesty before a release checklist | One design trade-off → `/ark-think` |
+| Quick honesty before a release checklist | One design trade-off → `/ark-explore` (one decision, 2–3 options) |
 
 ## Dual engine (mandatory)
 
@@ -90,10 +94,10 @@ ArkGate has **always-on Layers** plus opt-in extras. The user chooses extras; yo
 1. Prefix each finding or next step with **`[Layer]`** or **`[ArkRules]`** or **`[ArkRun]`** or **`[ArkOrder]`** (or a table with those headers).
 2. Never call an import-edge violation an “invariant” or an aggregate sensor a “layer deny.”
 3. Absence of `arkRules` is **valid** — do not force ArkRules unless the user wants them or residual inventory clearly wants a pilot.
-4. Editing `arkrules/*` or promoting modes is **`/ark-adopt`** / leftover **`/ark-contract`**; fixing code under a structure sensor is leftover **`/ark-fix`** / **`/ark-loop`** or **`/ark-autopilot`** (judgment, never invent mechanical-safe).
-5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
+4. Editing `arkrules/*` or promoting modes is **`/ark-adopt`**; fixing code under a structure sensor is **`/ark-autopilot`** (judgment, never invent mechanical-safe).
+5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` / `INVARIANT_CATALOG_EMPTY` with `evidence.arkruleId`.
 5b. Invariant coverage is a **text match, never an execution**: a file walk plus the invariant id in a `describe`/`it` title. Never report `INVARIANT_UNCOVERED: 0` as “the tests pass” or “the tests run” — ArkGate does not run tests and reads no runner config. When the project declares `coverage.coverageRoots`, a covering test found outside them raises the advisory `INVARIANT_COVERAGE_OUTSIDE_ROOTS`; without that declaration ArkGate makes no claim about where tests run.
-6. Extras silent when off. Doctor `arkRun` is `notAScore`. Do not force extras. Do not invent `/ark-run` or `/ark-order`.
+6. Extras silent when off. Doctor `arkRun` / `arkOrder` is `notAScore`. Do not force extras. Wire one kernel candidate via `/ark-runtime`; one order-plane candidate via `/ark-order`. Do not invent `/ark-run`.
 
 
 ### Coverage + ArkRules
@@ -143,10 +147,10 @@ because governed% is 100% and plan is empty.
 
 ## Related onboarding
 
-- **Greenfield:** low governed% → `/ark-architect` or `ark-check --recommend`.
+- **Greenfield:** low governed% → `/ark-adopt` or `ark-check --recommend`.
 - **Brownfield:** `/ark-adopt` for action; this skill for fitness metrics.
 - **Pattern / spaghetti residual:** `/ark-explore` dual-plan seed / shape-focus.
-- **Business rules loose:** note in table; mining action → `/ark-adopt` or `/ark-contract`.
+- **Business rules loose:** note in table; mining action → `/ark-adopt`.
 
 ## Checklist (sensor + light code)
 
@@ -159,8 +163,8 @@ because governed% is 100% and plan is empty.
 7. **Governed%** + unclassified + `suggestions` from `--coverage --json`.
 8. Concentrated edges in check `summary` → contract smell, not N freezes.
 9. `layersWithoutRules` + empty cores with I/O under Application (false-green).
-    On false-green: **STOP — do not continue this skill as complete.** **STOP — false-green: invoke /ark-adopt or /ark-contract before claiming ENFORCE.** Do not claim goal.met / ENFORCE from type-only cleanup while doctor reports `contract-false-green-io-under-application`.
-    On one-edge wall: **STOP — do not continue this skill as complete.** **STOP — concentrated edge: invoke /ark-contract with source evidence** (do not freeze a wrong contract or grind N freezes).
+    On false-green: **STOP — do not continue this skill as complete.** **STOP — false-green: invoke /ark-adopt before claiming ENFORCE.** Do not claim goal.met / ENFORCE from type-only cleanup while doctor reports `contract-false-green-io-under-application`.
+    On one-edge wall: **STOP — do not continue this skill as complete.** **STOP — concentrated edge: invoke /ark-adopt with source evidence** (do not freeze a wrong contract or grind N freezes).
 10. Runtime kernel / Nest only if deps prove it — never force-fit.
 
 ## Output format

package/templates/skills/ark-explain.md

@@ -5,9 +5,13 @@ description: Explain the rules file in plain language and generate the HTML repo
 
 # /ark-explain — Understand this project's architecture
 
+**Contener · Guiar · Ordenar.** In plain words: contain the write, guide the next
+step, order leftover mess. This door is **Guiar**: teach the path in plain language.
+Skills never enforce — CLI / hooks / CI do.
+
 **Not a first-run door.** Teach / HTML tour only. Session 0 → **`/ark-adopt`**.
 Map → **`/ark-explore`**. Apply → **`/ark-autopilot`**.
-Do not send the user to leftover `/ark-contract` or `/ark-fix`.
+Wire ArkRun → **`/ark-runtime`**. Wire ArkOrder → **`/ark-order`**.
 
 The user wants to understand the architecture, a specific rule, or why the gate blocked them.
 
@@ -75,15 +79,17 @@ ArkGate has **always-on Layers** plus opt-in extras. The user chooses extras; yo
 2. Never call an import-edge violation an “invariant” or an aggregate sensor a “layer deny.”
 3. Absence of `arkRules` is **valid** — do not force ArkRules unless the user wants them or residual inventory clearly wants a pilot.
 4. Editing `arkrules/*` or applying structure fixes is **`/ark-adopt`** / **`/ark-autopilot`** (never invent `mechanical-safe`).
-5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
-6. Extras silent when off. Doctor `arkRun` is `notAScore`. Do not force extras. Do not invent `/ark-run` or `/ark-order`.
+5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` / `INVARIANT_CATALOG_EMPTY` with `evidence.arkruleId`.
+6. Extras silent when off. Doctor `arkRun` / `arkOrder` is `notAScore`. Do not force extras. Wire one kernel candidate via `/ark-runtime`; one order-plane candidate via `/ark-order`. Do not invent `/ark-run`.
 
 
 ### Explain + ArkRules
 - HTML/plain tour: section **Layers** and section **Rules under contract (ArkRules)** —
   when `arkRules` is active the showcase lists **per-layer counts**, **structure sensors**
   (id / sensor / mode), **uncovered** invariants (call them out), and a **covered sample**.
-  Inactive map stays a short opt-in note. Counts are never a score.
+  Compact doctor names ArkRules only when the map is on; absence stays silent.
+  Empty `invariants[]` on a populated Domain is residual (`INVARIANT_CATALOG_EMPTY`), not “all covered”.
+  Inactive HTML map stays a short opt-in note. Counts are never a score.
 - Spoken tour: name 2–4 real invariant IDs and one structure sensor from this repo’s
   `arkrules/*` (open the files — do not invent). Residual candidates → `--rules-inventory`.
 - **Teach the product model (required when arkRules is active):**
@@ -217,7 +223,7 @@ when residual signals remain.
 
 ## Related
 
-- Onboarding: `/ark-adopt` (or leftover `/ark-architect`), `ark-check --recommend`, `docs/enthusiast/README.md`
+- Onboarding: `/ark-adopt`, `ark-check --recommend`, `docs/enthusiast/README.md`
 - Brownfield: `/ark-adopt`, `docs/brownfield-adoption.md`
 - Autopilot: `/ark-autopilot` after the user understands the contract
 

package/templates/skills/ark-explore.md

@@ -5,7 +5,12 @@ description: Map import rules and leftover design. No apply. CLI is a sensor; yo
 
 # /ark-explore — Recon the real project (map only)
 
-**When:** you need a map, or leftover design work remains after imports look green.
+**Contener · Guiar · Ordenar.** In plain words: contain the write, guide the next
+step, order leftover mess. This door is **Guiar**: map leftover design so you can
+order a messy tree. Do not apply. Skills never enforce — CLI / hooks / CI do.
+
+**When:** you need a map, leftover design work remains after imports look green, or
+one bounded decision needs 2–3 enforceable options.
 **Not when:** the user wants edits applied (`/ark-autopilot`) or session 0 (`/ark-adopt`).
 
 ## Steps
@@ -17,6 +22,18 @@ description: Map import rules and leftover design. No apply. CLI is a sensor; yo
 ## Checklist
 
 - Doctor #1: if ENFORCE + empty plan A and gates are already installed → **Shape** (`/ark-explore` then `/ark-autopilot`). Do not say install-agent-gates.
+- When `--require-gates` / adopted-strict is on and doctor JSON has `adrPresence`,
+  the next step is a short note under `docs/adr/` (or `docs/decisions/`). Soft.
+  Not every change. Off when require-gates is off. No `/ark-adr`.
+- When doctor JSON has `statesTransitions` or `statusTransitionCatalog`, the
+  next step is a short states → transitions table (or one link) on the domain
+  doc already in play. Use catalog names when present. Soft. Silent when that
+  doc is absent or Domain has no status vocabulary. No `/ark-states`. Do not
+  invent states.
+- When doctor JSON has `noDomainFrontend`, Domain is empty and the UI holds the
+  rules. Next: one Domain file (`/ark-place`) then one small refactor
+  (`/ark-autopilot`). Soft. Silent when there is no frontend or Domain already
+  has files. No `/ark-domain`. Do not invent a Domain house.
 - Distinguish **missing** skills vs **stale** catalog. Installed ≠ stale.
 - Hook green is not tree green (scripted edits bypass PreToolUse).
 - Bug / false green / false red / missing doc / improvable behavior **in ArkGate itself** → draft one upstream GitHub issue (`pedroknigge/arkgate` or the installed package `repository.url`), **ask the human to confirm send**, then `gh issue create`. Never auto-file. Never file ArkGate defects on the consumer product repo.
@@ -102,7 +119,8 @@ If the consumer tree has a **domain glossary**, prefer its terms for layer/slice
 | Map / “what next?” / residual after ENFORCE | User wants edits applied → `/ark-autopilot` |
 | **Primary post-green door:** messy / leftover design work / “clarify for AI” | Skill-shopping coverage or think for the same leftover work |
 | Spaghetti brownfield: patterns concurrent, design-weak under green check | Only “governed% + gates installed?” numbers → `/ark-coverage` |
-| Dual-plan **seed** (A remediation + B pattern bets) without applying | One design trade-off between 2–3 options already mapped → `/ark-think` |
+| Dual-plan **seed** (A remediation + B pattern bets) without applying | Apply the chosen option → `/ark-autopilot`; new file → `/ark-place` |
+| One bounded decision: 2–3 enforceable options (folded from leftover `/ark-think`) | Full apply → `/ark-autopilot`; extra off → `/ark-adopt`; one kernel candidate → `/ark-runtime`; one order-plane candidate → `/ark-order` |
 | Path-correct vs design-correct honesty | Plain-language tour / HTML report → `/ark-explain` |
 
 **Post-green single path:** when doctor `postGreenPath` / ENFORCE · leftover design work is active, **this skill
@@ -173,20 +191,36 @@ ArkGate has **always-on Layers** plus opt-in extras. The user chooses extras; yo
 2. Never call an import-edge violation an “invariant” or an aggregate sensor a “layer deny.”
 3. Absence of `arkRules` is **valid** — do not force ArkRules unless the user wants them or residual inventory clearly wants a pilot.
 4. Editing `arkrules/*` or applying structure fixes is **`/ark-adopt`** / **`/ark-autopilot`** — explore does not write (never invent `mechanical-safe`).
-5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
-6. Never write `arkRun` or `arkOrder` from this skill. When extras are present, label residual **`[ArkRun]`** / **`[ArkOrder]`**. Do not invent `/ark-run` or `/ark-order`.
+5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` / `INVARIANT_CATALOG_EMPTY` with `evidence.arkruleId`.
+6. Never write `arkRun` or `arkOrder` from this skill. When extras are present, label residual **`[ArkRun]`** / **`[ArkOrder]`**. Wire one kernel candidate via `/ark-runtime`; one order-plane candidate via `/ark-order`. Do not invent `/ark-run`.
 
 
 ### Explore + ArkRules
 - Always run sensors for **both** planes when present: coverage/doctor **and** `--rules-inventory` if `arkRules` exists or brownfield may hide spaghetti rules.
 - Ranked table kinds may include `arkrules-opportunity` and `invariant-gap`.
+- Empty `invariants[]` on a populated Domain while `arkRules` is on is residual (`INVARIANT_CATALOG_EMPTY`), not done. Point at `arkrules/<Domain>.json`.
 - Dual-plan **B** may include: place advisory structure rules, extract one inventory candidate to Domain + `arkrules` entry, promote one covered invariant.
 - Field path: note whether starters emit `arkrules/*`.
 
 ### Explore + extras
 - Map extras when present; never write `arkRun` / `arkOrder`. Extra off → residual `n/a` / silent.
 - When `arkOrder` is on, name the valve: first freeze `release()`; later ξ is `proposeRelease` then `apply`; `refreshSigma`; ingest residual `absorb | escalate_up | hold` + `reasonCode`; capacity pack as data; in-memory `ReleaseStore` (`createMemoryReleaseStore`); thin travel `ingestTravelAction`. ArkRun residual may include information package `decisionTape` `{ xiHash, event, residual }`.
-- Field path may name the ArkOrder gallery on GitHub (`https://github.com/pedroknigge/arkgate/tree/main/examples/arkorder-billing`; not in the npm tarball — map only). First extra write is `/ark-adopt`; grind is `/ark-autopilot`.
+- Field path may name the ArkOrder gallery on GitHub (`https://github.com/pedroknigge/arkgate/tree/main/examples/arkorder-billing`; not in the npm tarball — map only). First extra write is `/ark-adopt`; wire one candidate is `/ark-order`; grind is `/ark-autopilot`.
+
+## One decision (2–3 options)
+
+When the job is **one** bounded import-rule or ArkRules choice (not a full map), stay here.
+Leftover `/ark-think` redirects here. Do not invent a third door.
+
+1. Open ≥5 source files on the decision surface. Name paths.
+2. Propose **2–3 options** that stay enforceable today. Label each by lens impact
+   (what residual improves / what stays out-of-scope). Always `notAScore`.
+3. Recommend one option + why it is enforceable. Pilot + kill-switch if the choice
+   adds a layer or wall.
+4. Hand off: apply → `/ark-autopilot`; new file → `/ark-place`; extra off → `/ark-adopt`;
+   one kernel candidate → `/ark-runtime`; one order-plane candidate → `/ark-order`.
+
+Never weaken `ark.config.json` to pass. Never silent judgment auto-apply.
 
 ## Output mode (pick one — do not invent a fourth)