arkgate 4.6.0 → 4.6.2

package/templates/skills/ark-fix.md

@@ -1,81 +1,41 @@
 ---
 name: ark-fix
-description: Resolve Ark architecture violations at the root cause — read importers and product context, design ports/adapters/moves/intent alignment. Never weaken the contract. CLI only validates.
+description: Shortcut to /ark-autopilot for a small violation cluster. Deprecated as a first-class door.
 ---
 
-# /ark-fix — Fix architecture violations at the root
+# /ark-fix — Shortcut to /ark-autopilot
 
-You fix violations Ark reports. Prefer structural fixes over silencing the gate.
-**Read the surrounding product code** (callers, package role, feature ownership) — not only
-the two files on the violation edge.
+**Not a first-run door.** This leftover name is a shortcut. Gate violations are
+**`/ark-autopilot`**. Do that job now. CLI only validates.
 
-## Improvement compass (process preflight)
+## Autonomy contract
 
-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.
+Invoking this leftover name **is** the approval to write the fix. Open importers,
+design the port/move, apply, `ark-check`. Never weaken the config. Never invent
+`mechanical-safe` kinds.
 
-**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.
-
-**Name residual lenses** on each cluster (SoC, DIP, coupling, …). Still no weaken-gate to clear a lens.
-
-## Deep modules (process)
+## When / not when
 
-- Prefer fixes that leave a **deep module** at a named **seam** (port in the owning layer; adapter outside).
-- Apply the **deletion test** before extracting a layer “just so tests can mock it.”
-- After a port/inject fix, **test at the public interface** of the seam (match remediation `nextAction` language), not only private internals.
+| Use this leftover name when… | Prefer instead |
+|------------------------------|----------------|
+| One change / small cluster just failed the gate | **`/ark-autopilot`** |
+| Judgment design for a known violation | Session 0 / false-green → **`/ark-adopt`** |
 
-## When / not when
+## Plan B one-pilot checklist (when leftover design, not a single edge)
 
-| Use `/ark-fix` when… | Do **not** use it when… |
-|----------------------|-------------------------|
-| One change / small cluster just failed the gate | Bulk residual / many edges → `/ark-loop` or `/ark-autopilot` |
-| Need a structural fix (port, move, intent rename) | Map residual / pattern Shape plan → `/ark-explore` |
-| Judgment design for a known violation | Contract wrong / false-green → STOP to `/ark-contract` / `/ark-adopt` |
-
-When the fix is really a **Shape** extraction (I/O out of routes, god module split), write an
-**extraction card** before editing — same template as `docs/brownfield-adoption.md`
-§6 and explore §G. Fixed fields (never mechanical-safe, never silent B apply).
-
-### Plan B one-pilot checklist (when Shape residual, not a single edge fix)
-
-Empty plan A + `designWeak` is **not** architecture finished. One pilot only:
-
-1. **Confirm** doctor `designFitness.designWeak` / non-empty `patternBets` (or agent-detected smell).
-2. **One pilot** — prefer `pilotLoop.nextPilot`; never multi-batch concurrent Shape extractions.
-3. **Extraction card** with **Kill-switch** + falsifiable Success (required).
-4. **User OK** before apply — `autoApplyPlanBForbidden` / never mechanical-safe.
-5. **Edit only that pilot scope** — then `ark-check` / re-doctor; residual outside pilot may remain.
-6. **Stop** if kill-switch fires; do not open pilot #2 in the same batch.
-
-```text
-### Extraction card
-Pilot: <one directory or feature path — or pilotLoop.nextPilot.pilotTarget>
-Smell: <doctor designSmells id if present>
-Move: <verbatim relocate / split>
-Do not: rewrite queries; weaken ark.config; invent mechanical-safe kinds; big-bang; multi-pilot batch
-Success: <falsifiable — re-doctor on pilot paths>
-Kill-switch: <stop condition — required>
-Next: re-run ark-check; shrink baseline if applicable
-```
+Empty plan A + leftover design work is **not** architecture finished. One pilot only.
+Write an **extraction card** (`docs/brownfield-adoption.md` §6) — never mechanical-safe,
+never silent B apply. **Kill-switch** required. `multiPilotBatchForbidden` — never
+multi-pilot batch.
 
 ## Dual engine (mandatory)
 
 | Engine | Role |
 |--------|------|
-| **Deterministic** | Violation list, plan kinds, post-edit `ark-check` |
-| **Exploratory** | Why this edge exists in *this* product; better home; manifiesto if the rule is business |
-
+| **Deterministic** | CLI / MCP / contract sensors — exit codes, plan kinds, coverage numbers, install status |
+| **Exploratory** | You open **this** repo's real files and product surface before concluding |
 
+The CLI is a **sensor**, never the whole job. Claiming done without the exploratory bar for this skill is **incomplete**.
 
 ## MCP workspace binding (mandatory)
 
@@ -88,89 +48,25 @@ 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`.
-
-
-### Fix + ArkRules
-- Classify each violation: `LAYER_*` / capability → **[Layer]**; `ARKRULE_*` / `INVARIANT_*` → **[ArkRules]**.
-- Structure sensor fixes are judgment (ports, factories, private state) — not mechanical-safe.
+Label findings **`[Layer]`** vs **`[ArkRules]`**. Structure sensor fixes are judgment.
 
 ## 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.
+If the host supports **parallel subagents**, fan out read-only scouts; otherwise
+**fall back to sequential**. Never weaken the gate.
 
 ## 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 first:** `/ark-explore` when the violation is one of many structural smells.
-- **peerIsolation / cross-slice:** always **judgment** — extract to shared, events/ports, or redesign ownership. Never auto-apply cross-feature or cross-context moves.
-- **`vertical-slice` ownership:** feature code stays under `src/features/<slice>/…` (no sibling-slice imports); shared primitives in `src/shared/`; infra in `src/lib/`; shell in `src/app/`. Cross-feature edges are peerIsolation — extract shared or use events/ports.
-- **`ddd-bounded-contexts` ownership:** code under `src/contexts/<context>/{domain,application,infrastructure,presentation}/`; shared kernel only under `src/shared/kernel/`. Cross-context imports (same or cross technical layer) are peerIsolation — integrate via application APIs/events, not peer technical layers.
-- **Default path:** `ark start` → `/ark-autopilot` → `ark-check --doctor`.
+- **Greenfield:** `/ark-adopt` or `ark-check --recommend` / `ark start`.
+- **Brownfield:** `/ark-adopt`.
 
-## Anti-wrapper rule (mandatory)
+## Steps
 
-**Forbidden:** only listing violations from JSON without reading importers/targets.
-
-**Required:**
-1. Run `ark-check` as **sensor** (and `--plan --json` if multi-step) — CLI validates; you remediate.
-2. **Read** each violated file and its import target (plus callers that explain product role).
-   If the wall is a concentrated contract smell: **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 false-green cores: **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`.
-   If many residuals: **STOP — do not continue this skill as complete.** **STOP — bulk residual debt: invoke /ark-loop or /ark-autopilot** instead of ad-hoc multi-file grinding without a plan.
-3. **“Así te lo re-soluciono”** — concrete change before editing.
-4. After edits: `ark-check --strict-config` (and baseline if configured).
-
-## Common fix patterns
-
-| Symptom | Fix |
-|---------|-----|
-| App → Presentation type-only | Extract type to application/core; re-export from UI |
-| App → Presentation value (UI in core) | Move component wrappers to presentation |
-| Domain → outer layer | Port/interface in Domain; adapter outside; or relocate false Domain file (`**/types.ts` trap) |
-| Intent prefix mismatch | Rename intent to layer’s `intentPrefixes` or fix prefix in config via `/ark-contract` |
-| Forbidden global in Domain | Inject a port (Clock, Id, Http) — don’t allow `Date.now` in Domain |
-| Concentrated edge wall | Stop grinding; `/ark-contract` facade/surface split |
-
-## Manifiesto
-
-If the “fix” is really a missing business intent or Domain home for a rule:
-
-- Propose intent name + layer placement.
-- Register / place code so `ark_manifest` / config can enforce it.
-- Do not only delete the import.
-
-## Rules
-
-- No `ark-*-disable`, no allowing a bad edge “to finish”, no baselining a **new** violation you introduced.
-- Prefer mechanical-safe kinds when the plan tags them; otherwise design judgment carefully.
-- Code only — no DB migrations unless user asked.
+1. Sensor: `ark-check` / `--plan --json`.
+2. If false-green or concentrated edge: **STOP — do not continue this skill as complete.**
+   **STOP — false-green:** / **STOP — concentrated edge:** execute **`/ark-adopt`** in this turn.
+3. Otherwise execute **`/ark-autopilot`** for the cluster (extraction card if Shape).
+4. Re-check.
 
 ## Mechanical-edit hygiene (outcome gate)
 
@@ -179,24 +75,9 @@ If the “fix” is really a missing business intent or Domain home for a rule:
 - 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 findings (physical cohesion — never mechanical)
-
-If `doctor.physicalCohesion` fires while you fix: do **not** fold reshape moves into your fix
-batch. Physical moves run only through `/ark-loop`'s one-pilot loop; merge decisions only as
-`/ark-architect` merge cards. A cohesion finding is context for your fix, never a license to
-reorganize. Respect `physicalCohesion.reshapeDecisions`: never revive a current rejected/deferred
-target from the still-visible facts. If the user makes a verdict while reviewing the finding,
-record its exact `decisionTarget` + reason in `.ark/reshape-decisions.json`; never infer one from
-golden-pattern prose.
-
-## Done
-
-- Targeted violations gone; no new ones.
-- Report: what moved, what was intentional default, what needs user decision.
-
 ## Completion contract (skill incomplete if missing)
 
-End with **exactly** these headings (markdown `###`):
+Skill incomplete if missing any field below.
 
 ### Completion
 - **Sensor:** commands/tools run
@@ -204,9 +85,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-adopt` / `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/skills/ark-loop.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.
+**Not a first-run door.** This leftover name is a shortcut. 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/skills/ark-place.md

@@ -1,10 +1,29 @@
 ---
 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?
 
+**When:** you are adding a new file or artifact and need the layer, folder, and name.
+**Not when:** session 0 / config is missing or lying (`/ark-adopt`) or an existing violation cluster (`/ark-autopilot`).
+
+## Steps
+
+1. Bind identity if using MCP (`ark_identity` with the exact project root).
+2. Place the file (`ark_place` or read `ark.config.json`).
+3. Write it there. Then `arkgate-check`.
+
+## 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 +53,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 +102,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,18 +151,20 @@ 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 doctor is **ENFORCE · design-weak** and the user is asking to reshape existing structure
+- 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 shows leftover design work 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
   batch reshape from this skill.
@@ -159,8 +180,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/skills/ark-runtime.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/skills/ark-think.md

@@ -5,6 +5,10 @@ description: Host-side architectural reasoning — 2–3 enforceable options on
 
 # /ark-think — Architectural reasoning (host LLM only)
 
+**Not a first-run door.** One decision only. Session 0 → **`/ark-adopt`**.
+Full map → **`/ark-explore`**. Apply → **`/ark-autopilot`**.
+Do not send the user to leftover `/ark-contract` or `/ark-fix`.
+
 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 +43,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