arkgate 4.6.0 → 4.6.1

package/templates/agent-skills/ark-loop/SKILL.md

@@ -1,71 +1,34 @@
 ---
 name: ark-loop
-description: Drive ark-check --plan to zero active violations. Read real source, auto-apply only mechanical-safe kinds, design judgment from the product tree. CLI validates — you edit code.
+description: Shortcut to /ark-autopilot for driving plan A to zero. Deprecated as a first-class door. CLI validates — you edit code.
 ---
 
-# /ark-loop — Apply the plan safely
+# /ark-loop — Shortcut to /ark-autopilot
 
-Read Ark’s classified **plan**, work toward **goal.met**, one small step at a time,
-validating every change with `ark-check` and rolling back regressions.
+**Deprecated as a first-class door.** Driving `--plan` to `goal.met` is **`/ark-autopilot`**.
+Do that job now. Auto-apply only the four `mechanical-safe` kinds; judgment you write.
 
-Deterministic kinds stay **tight**. Your job is still **exploratory on the files**: open
-importers/targets, see if the plan step is a symptom of wrong shape / false Domain / I/O
-under Application — escalate to `/ark-contract` or `/ark-explore` when the wall is structural.
+## Autonomy contract
 
-## Improvement compass (process preflight)
-
-When doctor is available, read `doctor.improvementCompass` (or the human **Improvement compass** section).
-Name 1–3 **residual** lenses in plain language before skill-shopping. Always `notAScore` — never invent
-0–10 scores or Excellent/Good ranks.
-
-**What the user should feel next:** fewer blocked AI writes, clearer folders, safer domain — then jargon.
-
-**Anti false-done:** empty plan A + residual lenses / design-weak → **Incomplete? yes**. Green edges alone
-are not “architecture finished.”
-
-**AI-easy architecture:** ports over concrete I/O in domain; one concern per module; golden pattern for
-new files; place before write (`/ark-place` / prepare-write).
-
-**Out of scope (honest):** scalability/performance, full app-security tooling (SAST), and full resilience
-patterns are **out-of-scope** lenses — say so; do not invent Ark enforcement for them.
-
-**Lens language on each cluster** while looping edges; residual shape lenses hand off to explore/autopilot.
-
-## Deep modules (process)
-
-- Judgment remediations that introduce ports: **name the seam**, prefer deep modules, **test at the public interface**.
-- Do not invent pass-through files that fail the **deletion test** just to clear a plan step.
-- Empty plan A is edge residual only — Shape residual still needs explore/autopilot; green edges ≠ feature done.
+Invoking this leftover name **is** the approval to apply plan A. Open every step file.
+Write. Re-check. Empty plan A + leftover design → **`/ark-explore`** then **`/ark-autopilot`**
+for one extraction card (never mechanical-safe B).
 
 ## When / not when
 
-| Use `/ark-loop` when… | Do **not** use it when… |
-|-----------------------|-------------------------|
-| Plan A has steps; drive to `goal.met` | Plan A empty — **stop**; residual Shape → `/ark-explore` / `/ark-autopilot` B |
-| Mechanical-safe + approved judgment only | Full product recon first → explore inside `/ark-autopilot` |
-| User already has a plan and wants the apply loop | Brownfield contract false-green → `/ark-adopt` |
-
-**Empty plan is not success for the product** — only for *edge remediation*. If `goal.met` and
-(`goal.designWeak` or non-empty `patternBets` from `--plan --json`): do **not** invent
-mechanical-safe kinds; hand off `/ark-explore` shape-focus or `/ark-autopilot` for dual-plan B.
-Pattern bets always have `neverMechanicalSafe: true` — extraction cards only
-(`docs/brownfield-adoption.md` §6).
-
-## Related onboarding
-
-- **Greenfield:** `/ark-architect` or `ark-check --recommend` / `ark start`.
-- **Brownfield:** `/ark-adopt` — match contract to reality; do not force a starter preset.
-- **Map / opportunities:** `/ark-explore`.
-- **Default path:** `ark start` → `/ark-autopilot` → `ark-check --doctor`.
+| Use this leftover name when… | Prefer instead |
+|------------------------------|----------------|
+| Plan A has steps; drive to `goal.met` | **`/ark-autopilot`** |
+| Mechanical-safe + judgment apply | Map only → `/ark-explore`; session 0 → `/ark-adopt` |
 
 ## Dual engine (mandatory)
 
 | Engine | Role |
 |--------|------|
 | **Deterministic** | Only the four `mechanical-safe` kinds auto-apply; plan tags; gate re-check |
-| **Exploratory** | Read sources; detect concentrated edges / false-green / wrong layer home before grinding |
-
+| **Exploratory** | Read sources; detect concentrated edges / false-green before grinding |
 
+The CLI is a **sensor**, never the whole job. Claiming done without the exploratory bar for this skill is **incomplete**.
 
 ## MCP workspace binding (mandatory)
 
@@ -76,67 +39,30 @@ 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 + ArkRules (mandatory, except /ark-runtime)
-
-ArkGate has **two opt-in planes**. The user chooses which to use; you **always label** findings so they never blur.
-
-| Plane | What it protects | Where it lives | Sensors / tools |
-|-------|------------------|----------------|-----------------|
-| **Layers** (inter-layer) | Who may import whom, capabilities, pure/forbiddenGlobals, peerIsolation | `ark.config.json` → `layers[]`, `rules[]` | graph check, baseline edges, doctor coverage % |
-| **ArkRules** (intra-layer) | Structure inside a layer + domain invariants as data | `arkRules` map + `arkrules/<ExactLayerName>.json` | structure sensors, invariant coverage, `--rules-inventory`, doctor `rulesUnderContract` |
-
-**Rules for every report / answer:**
-1. Prefix each finding or next step with **`[Layer]`** or **`[ArkRules]`** (or a two-column 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-contract`**; fixing code under a structure sensor is **`/ark-fix`** / **`/ark-loop`** (judgment, never invent mechanical-safe).
-5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
+Atomic multi-file work uses **`ark_prepare_change`** with the same matched `project` envelope.
 
+## Dual plane — layers + ArkRules (mandatory, except /ark-runtime)
 
-### Loop + ArkRules
-- Drive plan to zero **active** debt on the plane the user cares about; keep **[Layer]** and **[ArkRules]** queues separate.
-- One pilot at a time for ArkRules extraction cards (`pilotLoop` / inventory).
+Label findings **`[Layer]`** vs **`[ArkRules]`**. Never invent `mechanical-safe` kinds.
 
 ## Subagent fan-out (optional, host-dependent)
 
-When the user asks to go faster **or** the work naturally splits (multiple packages,
-feature dirs, plan clusters), you **may** dispatch **subagents**:
-
-| Host capability | Behavior |
-|-----------------|----------|
-| **Parallel subagents supported** (e.g. multi-agent / `spawn_subagent` / concurrent Agent tools) | Launch **2–N** agents in **one wave** with **disjoint path scopes**. Prefer **read-only** explore agents for mapping; at most **one writer** unless the host gives isolated worktrees. Parent merges findings, then runs `ark-check` once. |
-| **Not supported** (single agent only) | **Fall back to sequential** — same checklist, one cluster/step at a time. Never claim parallel work you did not run. |
-
-**Rules:**
-1. Give each subagent a **tight brief**: paths in scope, sensor commands allowed, deliverable shape (paths opened + findings JSON or bullets).
-2. **No shared mutable files** across parallel writers.
-3. STOP handoffs and dual-engine rules still apply in every agent.
-4. Parent owns the **### Completion** block (union of **Opened**, single **Handoff**).
-5. Do **not** use subagents to weaken the gate or invent `mechanical-safe` kinds.
-
-## Anti-wrapper rule (mandatory)
+If the host supports **parallel subagents**, fan out read-only scouts; otherwise
+**fall back to sequential**. Never weaken the gate.
 
-**Forbidden:** re-printing plan JSON without opening sources, or inventing new “safe” kinds.
-
-**Required:**
-1. `--plan --json` as sensor.
-2. For each step you touch: **read** `file` and `target` source (and enough callers to know the edge).
-3. **“Así te lo re-soluciono”** — exact edit before applying.
-4. After each apply: full gate re-run; rollback if targeted violation remains or new ones appear.
-5. If one edge dominates: **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).
-6. If empty cores + I/O under Application: **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`.
+## Related onboarding
 
-## mechanical-safe only (auto)
+- **Greenfield:** `/ark-adopt` or `ark-check --recommend` / `ark start`.
+- **Brownfield:** `/ark-adopt`.
 
-| `remediationKind` | What to do |
-|-------------------|------------|
-| `type-only-import-move` | Move type to owning layer; re-export for back-compat |
-| `pure-type-file-relocate` | Relocate pure-type file to owning layer (or rename out of false Domain globs) |
-| `import-type-from-pure-type-module` | Convert value import of pure-type module to `import type` |
-| `import-type-of-type-exports` | Convert value-syntax named import/export of type-only exports from a mixed module to `import type` / `export type` |
-| *(none for port-proof)* | **W6** `port-proof-inject-binding` is **judgment** (arity change) — propose inject; do not auto-apply |
+## Steps
 
-Never auto: free value uses of imports, multi-import files, dynamic import/require, forbidden globals, cycles, port-proof inject, multi-file adapter scaffolding without proof.
+1. `--plan --json`. Open every `steps[]` file.
+2. If one edge dominates: **STOP — do not continue this skill as complete.**
+   **STOP — concentrated edge:** execute **`/ark-adopt`**.
+3. If empty cores + I/O under Application: **STOP — do not continue this skill as complete.**
+   **STOP — false-green:** execute **`/ark-adopt`**.
+4. Else execute **`/ark-autopilot`** (mechanical-safe + judgment). Extraction card for Shape B.
 
 ## Mechanical-edit hygiene (outcome gate)
 
@@ -145,53 +71,9 @@ Never auto: free value uses of imports, multi-import files, dynamic import/requi
 - A convention-only `*-data.ts` stub is not a fix: move the real code or **leave the placeholder file uncreated**; never write `import "server-only"; export {}` as an empty naming token.
 - Keep the edit only when the **previously clean file stays typecheck-clean**. Otherwise roll it back and treat the change as judgment.
 
-## Reshape pilots (physical cohesion — physical cohesion, advisory)
-
-When `ark-check --doctor --json` carries `doctor.physicalCohesion.reshapePilot.nextPilot`,
-you may run **that one pilot** — never more:
-
-1. Read `physicalCohesion.reshapeDecisions` first. A current rejected/deferred target has no live
-   card: respect the explicit record and do not reconstruct it from raw facts. Read a live card's
-   `pilotTarget`, `decisionTarget`, `moveSample`/`movesTotal`, `successSignal`, `killSwitch`, `doNot[]`.
-2. Moves are **proposed only** — enumerate the full move set for the pilot anchor, express it as
-   an architecture change map, and validate through the atomic preflight (`ark_prepare_change`
-   with the matched `project` envelope / the write gate) **before** any file moves. A move the preflight rejects is a finding, not a
-   thing to force.
-3. Never move anything under `app/` or `pages/` (fixed by framework convention). Never merge
-   files here — merges are judgment cards for `/ark-architect` / `/ark-fix`.
-4. After the move set: full gate re-run + re-doctor. Success = the concept's cluster count drops
-   and the verdict stays green; otherwise use the kill switch (revert the move set, nothing else).
-5. Re-doctor decides whether a next card exists. One pilot per loop iteration, always.
-6. If the user accepts, defers, or rejects the target, persist that explicit verdict in
-   `.ark/reshape-decisions.json` using the card's exact `decisionTarget`, a reason, and optional
-   `reviewBy`. `accepted` keeps this execution path; `deferred`/`rejected` stop repeat pressure.
-   Never infer a decision from `.ark/golden-pattern.json` prose.
-
-## Steps
-
-1. **Plan** — `ark-check --plan --json` (+ `--baseline` if used). If `goal.met`: stop **A**;
-   if design-weak residual is visible, hand off explore/autopilot B — do not claim architecture done.
-2. **Worktree** — prefer discardable git worktree.
-3. **Apply mechanical-safe** one-by-one with validate/rollback.
-4. **Judgment** — propose with source-based design; apply only if user approved (or parent autopilot said full apply).
-5. **Re-plan** after each round until dry, `goal.met`, or only judgment left without approval.
-6. **Report** — auto-applied / proposed / deferred with paths; never claim clean if skipped.
-
-## Operating rules
-
-- Never weaken the gate (no rule disables, no fresh baselining of new debt).
-- Concentrated single edge → stop and hand to `/ark-contract` with code evidence.
-- When unsure behavior preservation → judgment, not mechanical-safe.
-
-## Done criteria
-
-- Gate confirms each kept edit.
-- Honest residual list with **Así te lo re-soluciono** for anything left.
-- If residual steps hide domain/business rules in the wrong layer, call out **manifiesto** work (`intentPrefixes` / Domain placement) via `/ark-contract` or `/ark-adopt`.
-
 ## Completion contract (skill incomplete if missing)
 
-End with **exactly** these headings (markdown `###`):
+Skill incomplete if missing any field below.
 
 ### Completion
 - **Sensor:** commands/tools run
@@ -199,9 +81,5 @@ End with **exactly** these headings (markdown `###`):
 - **Result:** one-line outcome
 - **Planes:** one-line split of residual **[Layer]** vs **[ArkRules]** (or `n/a` if unused)
 - **Compass:** top residual lenses | `n/a`
-- **Done axes:** architecture residual (status/doctor/compass) | feature/ticket residual (outside package). Enforce green ≠ feature done
-- **Handoff:** `/ark-…` / CLI / `none`
+- **Handoff:** `/ark-autopilot` / `/ark-explore` / `none`
 - **Incomplete?** `no` | `yes — <what is missing>`
-
-If a **STOP** handoff applies and you continued as if done, set **Incomplete?** to `yes`.
-**Skill incomplete if missing** any of the bullets above.

package/templates/agent-skills/ark-place/SKILL.md

@@ -1,10 +1,20 @@
 ---
 name: ark-place
-description: "Where does new code go? Names the layer, directory, and naming for a new artifact from the contract, and scaffolds it there. Autonomous."
+description: "Where does new code go? Names the layer, directory, and naming for a new artifact from the contract, and writes it there. Autonomous."
 ---
 
 # /ark-place — Where does this code go?
 
+## Autonomy contract
+
+Invoking this skill **is** the approval. If the user described an artifact, **write the
+files** in this turn (prepare-write + scaffold). A path table alone is incomplete.
+The CLI is a **sensor and gate**. **CLI budget:** `ark_identity` then `ark_place` (or
+read `ark.config.json`); write; `ark-check`. Do not ask which layer they prefer.
+
+**Still never:** weaken `ark.config.json`; invent `mechanical-safe` kinds; claim leftover
+design work is finished because one file landed.
+
 ## Improvement compass (process preflight)
 
 When doctor is available, read `doctor.improvementCompass` (or the human **Improvement compass** section).
@@ -34,8 +44,8 @@ patterns are **out-of-scope** lenses — say so; do not invent Ark enforcement f
 
 | Use `/ark-place` when… | Do **not** use it when… |
 |------------------------|-------------------------|
-| New artifact: where + scaffold under contract | Existing violation fix → `/ark-fix` |
-| Naming / directory for a known kind | Contract layers wrong → `/ark-contract`; full shape choice greenfield → `/ark-architect` |
+| New artifact: where + **write** under the config | Existing violation cluster → `/ark-autopilot` |
+| Naming / directory for a known kind | Session 0 / config missing or lying → `/ark-adopt` (then come back) |
 
 The user describes something they need to build (a saga, a background job, an
 event handler, a repository, an HTTP client, a use case, a projection, …).
@@ -83,7 +93,7 @@ ArkGate has **two opt-in planes**. The user chooses which to use; you **always l
 1. Prefix each finding or next step with **`[Layer]`** or **`[ArkRules]`** (or a two-column 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-contract`**; fixing code under a structure sensor is **`/ark-fix`** / **`/ark-loop`** (judgment, never invent mechanical-safe).
+4. Missing layer home: add it via **`/ark-adopt`** in this session if needed, then write the file; never invent `mechanical-safe`.
 5. CLI helpers: `ark-check --rules-inventory --json`, doctor JSON `rulesUnderContract`, sensors emit `ARKRULE_*` / `INVARIANT_UNCOVERED` with `evidence.arkruleId`.
 
 
@@ -132,17 +142,19 @@ the same files or weaken the gate.
 3. **Answer concretely**: layer name, target directory (from the layer's
    `patterns`), intent-name prefix if the layer declares `intentPrefixes`, and
    which layers it may/may not import (from `rules`).
-4. **If the layer isn't adopted yet** (suggested but no directory): say so,
-   give the conventional directory from `suggestedLayers`, and offer
-   `/ark-contract` to adopt it — don't silently drop the code into a
+4. **If the layer isn't adopted yet** (suggested but no directory): write the
+   layer into `ark.config.json` (session-0 honesty — same as `/ark-adopt` for
+   that glob) **then** write the file. Don't silently drop the code into a
    wrong-but-existing layer.
-5. **If asked to create it**: scaffold the file(s) in place, following the
-   nearest existing sibling's style, and any port/adapter split the rules force.
+5. **Write it.** If the user described the artifact, scaffold the file(s) in
+   place this turn (prepare-write), following the nearest existing sibling's
+   style, and any port/adapter split the rules force. A path table without
+   files is incomplete unless they asked “where only.”
 
 ## Critical handoffs
 
-- If the user needs bulk adoption / wrong contract, not a single artifact: **STOP — do not continue this skill as complete.** **STOP — wrong skill: invoke /ark-adopt or /ark-contract** instead of ad-hoc multi-file grinding without a plan.
-- If contract lacks a home for the artifact: **STOP — do not continue this skill as complete.** Adopt the layer via `/ark-contract` first.
+- If the user needs bulk adoption / wrong config, not a single artifact: **STOP — do not continue this skill as complete.** Switch to **`/ark-adopt`** (write the path) instead of ad-hoc multi-file grinding without a plan.
+- If the config lacks a home for the artifact: add the layer **in this turn**, then write the file.
 - If doctor is **ENFORCE · design-weak** and the user is asking to reshape existing structure
   (not place one new artifact): place only the new file under the golden/contract home, then
   hand off **one** pilot via `pilotLoop.nextPilot` / `/ark-explore` shape-focus — never multi-pilot
@@ -159,8 +171,8 @@ the same files or weaken the gate.
 
 ## Related onboarding
 
-- Run **after** shape adoption: `/ark-architect` or `ark init --archetype` on greenfield;
-  `/ark-adopt` on brownfield.
+- Run **after** session 0: `/ark-adopt` (or `ark init --archetype` / `ark-check --recommend`
+  on greenfield). Brownfield: `/ark-adopt` first if the config is missing or lying.
 - `ark-check --recommend` / MCP `ark_recommend` picks phase-1 dirs; gallery starters in
   `examples/*-starter/` show correct placement per archetype.
 - Related demos: `docs/demos/` (write-gate self-correction, brownfield, autopilot).

package/templates/agent-skills/ark-runtime/SKILL.md

@@ -19,7 +19,7 @@ one feature at a time.
 
 This skill is **experimental runtime** only. Do **not** treat runtime adoption as residual on the
 resilience lens unless the user explicitly opts into the experimental kernel. Prefer doctor compass
-for static architecture residual; hand static residual to `/ark-explore` / `/ark-fix`.
+for static architecture residual; hand static residual to `/ark-explore` / `/ark-autopilot`.
 
 ## Dual engine (mandatory)
 
@@ -86,7 +86,7 @@ the same files or weaken the gate.
 
 ## Critical handoffs
 
-- No static gates yet: **STOP — do not continue this skill as complete.** Run `/ark-architect` or `/ark-adopt` first.
+- No static gates yet: **STOP — do not continue this skill as complete.** Run `/ark-adopt` first (`ark-check --recommend` / leftover `/ark-architect`).
 - Runtime companion unavailable from npm and no ArkGate source checkout: **STOP** and report the distribution boundary.
 - Inventory finds nothing: stop; do not introduce kernel speculatively.
 
@@ -102,7 +102,7 @@ the same files or weaken the gate.
 
 ## Related onboarding
 
-- Adopt static gates and application shape **first** (`/ark-architect`, `/ark-adopt`).
+- Adopt static gates and application shape **first** (`/ark-adopt`).
 - Runtime kernel is optional and separate from enthusiast onboarding.
 
 ## Verify and report

package/templates/agent-skills/ark-think/SKILL.md

@@ -5,6 +5,9 @@ description: Host-side architectural reasoning — 2–3 enforceable options on
 
 # /ark-think — Architectural reasoning (host LLM only)
 
+**Shortcut.** One decision only. Full map → **`/ark-explore`**. Apply → **`/ark-autopilot`**.
+Session 0 → **`/ark-adopt`**.
+
 You are the user's architecture thinking partner **inside** the project's Ark contract.
 This skill does **not** call any LLM API from the arkgate package. **You** (the host agent)
 reason; the write-gate and CI remain deterministic.
@@ -39,8 +42,8 @@ patterns are **out-of-scope** lenses — say so; do not invent Ark enforcement f
 | Use `/ark-think` when… | Do **not** use it when… |
 |------------------------|-------------------------|
 | One decision: new layer vs slice, port vs shared, peerIsolation choice | Full map / ranked residual / dual-plan seed → `/ark-explore` |
-| 2–3 options already bounded by a known surface | Apply remediation → `/ark-fix` / `/ark-loop` / `/ark-autopilot` |
-| Trade-offs before writing a **new** feature | Brownfield contract wrong / false-green → `/ark-adopt` then `/ark-contract` |
+| 2–3 options already bounded by a known surface | Apply remediation → `/ark-autopilot` |
+| Trade-offs before writing a **new** feature | Brownfield config wrong / false-green → `/ark-adopt` |
 | Explain *why* a rule exists in *this* tree | HTML tour → `/ark-explain`; fitness numbers → `/ark-coverage` |
 
 If you lack a product map and the tree is messy: run a **compressed** explore pass first

package/templates/agent-skills/ark-upgrade/SKILL.md

@@ -9,9 +9,14 @@ Upgrade the published `arkgate` package and its managed gates without treating a
 filename, package version, or similar-looking file as proof of ownership. The
 preview is the source of truth: inspect it before applying anything.
 
-For greenfield onboarding, start with `/ark-architect` (or
-`ark-check --recommend`); for a brownfield repository, use `/ark-adopt` before
-this upgrade flow.
+## Autonomy contract
+
+Invoking this skill **is** the approval. Preview, then `--apply` **in this turn**.
+Stopping at preview is incomplete unless the probe failed or a conflict needs
+`--accept-conflicts` / `--refresh-skills` consent.
+
+For session 0, start with `/ark-adopt` (or `ark-check --recommend`); brownfield
+honesty is `/ark-adopt` before this upgrade flow.
 
 ## Improvement compass (process preflight)
 
@@ -99,7 +104,7 @@ ArkGate has **two opt-in planes**. The user chooses which to use; you **always l
 1. Prefix each finding or next step with **`[Layer]`** or **`[ArkRules]`** (or a two-column 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-contract`**; fixing code under a structure sensor is **`/ark-fix`** / **`/ark-loop`** (judgment, never invent mechanical-safe).
+4. After upgrade, leftover architecture work is **`/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`.
 
 
@@ -241,9 +246,8 @@ ArkGate has **two opt-in planes**. The user chooses which to use; you **always l
    `doctor.deepModuleCoach` honesty. Run `npx arkgate agents-md --check` and
    `npx arkgate status --json`. If MCP was used, restart MCP after package bump and re-bind
    identity. Treat provider-unavailable CI required-check evidence as `unverified`, never as proof
-   that merges are blocked. If new violations appear, hand off to `/ark-fix` for a small set or
-   `/ark-loop` / `/ark-autopilot` for residual debt; do not regenerate a baseline without explicit
-   approval.
+   that merges are blocked.    If new violations appear, hand off to `/ark-autopilot`; do not regenerate a baseline without
+   explicit approval.
 
 ## Active host vs deferred hosts
 

package/templates/skills/ark-adopt.md

@@ -1,12 +1,39 @@
 ---
 name: ark-adopt
-description: Brownfield onboarding — match contract to real product code, classify ungoverned dirs, mine business rules, freeze only real debt, seed Shape dual-plan B for spaghetti residual. Deep source analysis required.
+description: Session 0 — mark the Ark path. Greenfield scaffold or brownfield honesty. Write ark.config, optional advisory ArkRules, baseline, and gates in this turn. CLI validates.
 ---
 
-# /ark-adopt — Bring Ark into an existing codebase
+# /ark-adopt — Mark the path (session 0)
 
-Goal: contract reflects **product reality**, most code governed, only genuine debt frozen
-with a burn-down. A green check over a wrong contract is a **false green**.
+Invoking this skill **is** the approval. Write the architecture config in this turn.
+Greenfield: scaffold like `--recommend` / today’s architect. Brownfield: match **product
+reality**, freeze only genuine debt. A green check over a wrong config is a **false green**.
+
+## Autonomy contract
+
+The CLI is a **sensor and gate**, never the deliverable. **CLI budget:** one
+`ark-check --recommend` or `--coverage` / `--doctor`; then write; then `ark-check`.
+Forbidden as the result: preview-only adopt, “approve?”, or `STOP — invoke /ark-architect`
+/ `/ark-contract`. Do that work **here**.
+
+**Still never:** weaken `ark.config.json`; invent `mechanical-safe` kinds; claim finished
+while leftover design work remains.
+
+**Team lock:** this door **is** a contract session (law-only). Do not mix product source
+into the same diff. After writes, validate with
+`ark-check --contract-diff --contract-session --base <merge-ref> --author <steward>`.
+If `stewards` is set, loosen and baseline-grow require a listed author. Feature work
+uses `/ark-place` / `/ark-autopilot` and must not touch the constitution.
+
+**Several hands → ask for stewards.** Read `doctor.stewardNudge` (or the human
+**Stewards (advisory)** line). Act when `needsStewards` **or** `drift` is true.
+**Ask once** before writing `stewards[]`. Identity is a **GitHub handle or email**
+(`pedroknigge` or the GitHub noreply mail), not git `user.name`. Empty list: use
+`proposed` (CODEOWNERS first, else git handles/emails; bots and display names stripped).
+Drift: CODEOWNERS handles in `missingFromList`, or “team grew” (author count > steward
+count) — ask who else owns the law. If the user says yes or names handles or emails,
+write them in this turn. If they say the list is still right, leave it. Never invent
+or auto-remove stewards.
 
 **Adopt is Align + Stabilize, then seed Shape.** Freezing debt without a pattern plan leaves
 spaghetti “ENFORCE · design-weak”. Always end with dual-plan **B** seeds (or handoff explore)
@@ -47,10 +74,10 @@ When present, prefer the consumer **domain glossary** for layer names, slice fol
 
 | Use `/ark-adopt` when… | Do **not** use it when… |
 |------------------------|-------------------------|
-| Existing messy repo; contract ≠ folders | Empty greenfield shape → `/ark-architect` |
-| False-green / concentrated edge needs contract truth | Map-only without writing config/baseline → `/ark-explore` |
-| Mine loose business rules into Domain / intents | Single violation fix → `/ark-fix` |
-| Freeze **real** debt after contract is honest | Grind plan A only → `/ark-loop`; full apply loop → `/ark-autopilot` |
+| Session 0: empty tree or existing repo needs an honest path | Map-only without writing config → `/ark-explore` |
+| False-green / concentrated edge needs config truth | Feature file only → `/ark-place` |
+| 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 |
 
 ## Dual engine (mandatory)
 
@@ -83,13 +110,13 @@ ArkGate has **two opt-in planes**. The user chooses which to use; you **always l
 1. Prefix each finding or next step with **`[Layer]`** or **`[ArkRules]`** (or a two-column 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-contract`**; fixing code under a structure sensor is **`/ark-fix`** / **`/ark-loop`** (judgment, never invent mechanical-safe).
+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`.
 
 
 ### Adopt + ArkRules
 - After classify: emit or refresh `arkRules` for matched layers (exact names; generic mold for unknowns).
-- Mine rules → inventory + propose invariants/structure; land via `/ark-contract`.
+- Mine rules → inventory + write advisory invariants/structure into `arkrules/<Layer>.json` **in this turn**.
 - Freeze baseline is **[Layer]** debt; inventory residual is **[ArkRules]** — report both.
 
 ## Subagent fan-out (optional, host-dependent)
@@ -111,10 +138,10 @@ feature dirs, plan clusters), you **may** dispatch **subagents**:
 
 ## Related onboarding
 
-- **Greenfield:** `/ark-architect` or `ark-check --recommend` / `ark start`.
-- **Brownfield:** `/ark-adopt` — match contract to reality; do not force a starter preset.
+- **Greenfield:** this skill + `ark-check --recommend` / `ark start` — write the scaffold here.
+- **Brownfield:** this skill — match config to reality; do not force a starter preset.
 - **Deep map only:** `/ark-explore`.
-- **Default path:** `ark start` → `/ark-autopilot` → `ark-check --doctor`.
+- **Default path:** `ark start` → **`/ark-adopt`** → `/ark-place` / `/ark-autopilot`.
 
 ## Anti-wrapper rule (mandatory)
 
@@ -143,18 +170,18 @@ Ark protects the **boundary around** a framework, not its internals. Nest/DI pub
    **ApplicationOrchestration**, not Presentation — do not reclassify API shells as UI.
 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.
-   If one edge dominates residual debt: **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).
+   If one edge dominates residual debt: **STOP — do not continue this skill as complete.** **STOP — concentrated edge:** rewrite `ark.config.json` **in this turn** with source evidence (do not freeze a wrong config or grind N freezes).
    Empty Domain/Persistence + I/O under Application → 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`.
+   **STOP — do not continue this skill as complete.** **STOP — false-green:** fix the config **in this turn** before claiming ENFORCE. Do not claim goal.met / ENFORCE from type-only cleanup while doctor reports `contract-false-green-io-under-application`.
 3. **Classify ungoverned** — use coverage `suggestions` **plus** dirs you discovered by reading;
-   add layers/patterns via `/ark-contract`.
+   add layers/patterns **here** (write `ark.config.json`).
 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
      (validation-in-controller, magic constants, anemic entities). Counts are **not a score**.
    - Propose: Domain files, `intentPrefixes`, intent names (`Domain.*` / `Application.*`), kernel `defineIntent` stubs if runtime is used;
-     land structure/invariant entries under `arkrules/<Layer>.json` via `/ark-contract` (ADR 0015 routing).
-   - Apply config through `/ark-contract` discipline; move pure rules into Domain when safe; validate with ark-check.
+     land structure/invariant entries under `arkrules/<Layer>.json` **in this turn** (ADR 0015 routing).
+   - Write the config; move pure rules into Domain when safe; validate with ark-check.
    - Deliver section **“Así te lo re-soluciono en el manifiesto”** with before/after contract snippets.
 5. **Freeze only real debt** — `--update-baseline` (zero debt → **no empty baseline file** left behind).
 6. **Gates + skills** — `--install-agent-gates` (CI monorepo-aware when `frontend/package.json` exists).
@@ -164,7 +191,7 @@ Ark protects the **boundary around** a framework, not its internals. Nest/DI pub
      domain logic in UI, or semantic false-green: emit **dual-plan B** (3–5 bets) with pilot,
      success signal, kill-switch, and extraction cards for I/O moves — same bar as `/ark-explore` §G.
    - Do **not** claim “adopt complete / healthy” solely because the check is green.
-   - Prefer handoff `/ark-autopilot` for B execution with user ok, or `/ark-explore` shape-focus
+   - Prefer handoff `/ark-autopilot` to apply one Shape refactor, or `/ark-explore` shape-focus
      if the user only wanted a plan.
 
 ## Operating modes