arkgate 2.1.0

package/docs/demos/03-copilot-autopilot.md

@@ -0,0 +1,83 @@
+# Demo: the co-pilot autopilot, end to end
+
+Take a project from "no guardrails" to "governed, cleaned up, and enforced" — the way a
+non-developer would, driving an agent. This is the Phase F→G→H→I flow (plan · guided setup ·
+loop · autopilot) in one sitting.
+
+## In one line
+
+`npx ark start` sets it up and shows a plan; **`/ark-autopilot`** (in your agent) carries the
+plan out — applying the safe fixes and proposing the rest, always validated by `ark-check`.
+
+## Prerequisites
+
+- Ark built or installed from this repository
+- An agent CLI (Claude, Cursor, Codex, Grok, …) for the `/ark-autopilot` and `/ark-loop` steps
+
+## Steps
+
+### 1. Guided setup (no architecture knowledge needed)
+
+```bash
+TMP=$(mktemp -d); cd "$TMP"
+git init -q                        # the loop works in a discardable worktree
+npm init -y >/dev/null
+npx ark start --yes
+```
+
+Ark describes the project's shape in plain language, writes `ark.config.json` + agent/CI gates,
+and prints the **plan** — how many fixes are _safe to auto-apply_ vs _need your decision_ —
+plus which **operating mode** applies: **suggest**, **adapt**, or **enforce**.
+
+On Nest/Next/express/library projects, init also merges framework filename conventions into
+the layer globs so day-one **governed%** is real (not a false-green empty contract).
+
+### 2. See the plan yourself (optional)
+
+```bash
+npx ark-check --plan            # human view (includes Governed: N%)
+npx ark-check --plan --json     # { ok, plan: { goal, counts, steps } }
+```
+
+Each step is tagged `mechanical-safe` / `judgment` / `deferred` with a `confidence` and a
+plain-language `rationale`. `goal.met` is true only when there are no active violations **and**
+governed coverage is meaningful — so a clean plan that checks almost nothing is not "done."
+
+### 3. Carry the plan out — the autopilot
+
+In your agent, run:
+
+```
+/ark-autopilot
+```
+
+It runs the whole flow (newbie tier): confirms the plan, hands off to `/ark-loop` to apply the
+`mechanical-safe` steps one at a time — **validating each with `ark-check` and rolling back any
+regression** — proposes each `judgment` step for a yes/no, loops until `goal.met`, and reports
+what was auto-applied vs proposed vs deferred. Nothing lands until you review the diff.
+
+Expert entry: skip the autopilot and use the pieces — `ark init` / `/ark-contract` to shape the
+contract, `ark-check --plan` for the work, `/ark-fix` for targeted fixes, `ark-check
+--strict-config` as the gate. Same contract, same gates; same suggest/adapt/enforce modes.
+
+### 4. It stays clean
+
+The gates installed in step 1 keep enforcing the architecture from now on — in CI, and at write
+time if the MCP hook is wired. Verify:
+
+```bash
+npx ark-check --root . --config ark.config.json --strict-config
+```
+
+## What this proves
+
+- **plan + goal** (Phase F): `ark-check --plan` classifies the work and defines "done" (with
+  governed% honesty).
+- **guided setup** (Phase G): `ark start` — no preset or skill name required; modes
+  suggest / adapt / enforce.
+- **loop** (Phase H): `/ark-loop` — safe, reversible, validated apply.
+- **autopilot** (Phase I): `/ark-autopilot` — the whole thing, with newbie/expert entry styles.
+- **field honesty** (2.0): framework overlays + no false-green at 0% governed.
+
+The classifier's precision (only provably-safe changes are ever `mechanical-safe`) is guarded
+by the classifier corpus test in `tests/unit/static-check/arkCheck.test.ts`.

package/docs/enthusiast/README.md

@@ -0,0 +1,62 @@
+# Ark — Architecture Co-pilot (enthusiast track)
+
+Plain-language onboarding for builders who use AI agents but are not professional
+developers. This track follows [Diátaxis](https://diataxis.fr/): tutorial, how-to,
+reference, and explanation.
+
+## How Ark talks to you (2.0)
+
+**Entry style** — who is driving: *newbie* (`ark start` / `/ark-autopilot`) vs *expert* (individual commands).
+
+**Operating mode** — what Ark is doing right now (one contract underneath):
+
+| Mode | Meaning |
+|------|---------|
+| **Suggest** | Propose an application shape and install a starter contract. |
+| **Adapt** | Match the contract to your real layout / raise governed coverage. |
+| **Enforce** | The contract actually governs your code; gates hold the line. |
+
+`ark start` and `ark-check --plan` will not claim "everything is guarded" while governed coverage is near zero. On Nest/Next/express starters, init also merges **framework filename conventions** into the layer globs so day-one coverage is real.
+
+## Start here
+
+| Type | Document | You will… |
+|------|----------|-----------|
+| **Tutorial** | [First project in 15 minutes](tutorial-first-project.md) | Walk the full path once: recommend → init → verify |
+| **How-to** | [Pick your application shape](how-to-pick-shape.md) | Run `--recommend` / `ark_recommend` and read the plan |
+| **How-to** | [Use a gallery starter](how-to-gallery-starter.md) | Copy a phase-1 scaffold that matches your archetype |
+| **How-to** | [Apply an enthusiast policy pack](how-to-policy-pack.md) | Write `ark.config.json` from a named preset |
+| **How-to** | [Install agent gates](how-to-agent-gates.md) | Wire the write gate and `/ark-*` skills |
+| **Reference** | [Archetypes and presets](reference-archetypes.md) | Look up playbook ids, presets, and phase-1 layers |
+| **Reference** | [Commands and artifacts](reference-commands.md) | `--recommend`, `--write-plan`, `ark-adoption-plan.json`, fix-class JSON |
+| **Explanation** | [Why application shape matters](explanation-application-shape.md) | Understand shapes vs frameworks and progressive phases |
+
+## Public demos (Phase D)
+
+Reproducible scripts — no video required:
+
+- [Write-gate self-correction](../demos/01-write-gate-self-correction.md)
+- [Brownfield baseline adoption](../demos/02-brownfield-baseline-adoption.md)
+## Gallery starters
+
+| Archetype | Directory |
+|-----------|-----------|
+| `crud-product` | [examples/crud-product-starter](../../examples/crud-product-starter/) |
+| `api-backend` | [examples/api-backend-starter](../../examples/api-backend-starter/) |
+| `worker-pipeline` | [examples/worker-pipeline-starter](../../examples/worker-pipeline-starter/) |
+| `multi-app-workspace` | [examples/multi-app-workspace-starter](../../examples/multi-app-workspace-starter/) |
+
+Deep teaching example (runnable API + break exercises): [hexagonal-order-api](../../examples/hexagonal-order-api/).
+
+## Brownfield vs greenfield
+
+| Situation | Use |
+|-----------|-----|
+| New or empty repo | `/ark-architect`, `ark-check --recommend`, gallery starters |
+| Existing messy codebase | `/ark-adopt`, [brownfield playbook](../brownfield-adoption.md) |
+
+## Related
+
+- [Agent integration guide](../agent-guide.md)
+- [Public demos](../demos/)
+- [Examples index](../../examples/README.md)

package/docs/enthusiast/explanation-application-shape.md

@@ -0,0 +1,29 @@
+# Explanation: why application shape matters
+
+Ark separates **what you are building** from **which framework you installed**.
+
+A “todo app with a database” is an application shape (`crud-product`). Next.js, Vite, or
+Prisma are detection signals that may raise confidence — they do not define the archetype
+label shown to you or your agent.
+
+## Progressive phases
+
+Phase 1 is deliberately small (typically 2–4 layers). Phase 2 and 3 unlock when you
+describe new capabilities (payments, email, background jobs, sagas). This keeps enthusiasts
+from drowning in the full 11-layer profile on day one.
+
+## Honesty over green
+
+`ark-check --strict-config` and `--coverage` report how much of the tree is actually
+governed. A passing check over 40% of files is not success — Ark says so explicitly.
+
+## Shapes map to presets, not ad-hoc folders
+
+Every suggestion traces to `templates/architecture-playbook.json`, named presets, or
+enthusiast policy packs. Agents must not invent `utils/` or `helpers/` as ungoverned dumping
+grounds — classify via `/ark-contract`.
+
+## When not to use enthusiast onboarding
+
+Existing large codebases need `/ark-adopt` and the [brownfield playbook](../brownfield-adoption.md):
+diagnose, fix the contract, freeze only real debt, burn down in order.

package/docs/enthusiast/how-to-agent-gates.md

@@ -0,0 +1,36 @@
+# How to install agent gates
+
+```bash
+npx ark-check --install-agent-gates
+npx ark-check --install-agent-gates --tools claude,cursor,codex,grok
+```
+
+Installs:
+
+- Write-gate hook configuration (Claude / Grok PreToolUse; Cursor advisory + MCP)
+- MCP server entry (`.mcp.json`, Cursor/Codex/Grok equivalents)
+- `/ark-*` skills including **`/ark-architect`** and **`/ark-autopilot`**
+
+| Host | Extra paths |
+|------|-------------|
+| Claude Code | `.claude/settings.json`, `.claude/skills/` |
+| Cursor | `.cursor/mcp.json`, `.cursor/rules/ark.mdc`, `.cursor/commands/` |
+| Codex | `docs/ark-codex-config.toml` + home MCP/prompts |
+| **Grok Build** | `.grok/config.toml`, `.grok/hooks/`, `.grok/skills/` |
+
+## Session hint
+
+`ark-mcp --session-context` appends when governed coverage is low:
+
+```
+New to Ark? Run /ark-architect or: ark-check --recommend
+```
+
+## Verify gates
+
+```bash
+npx ark-check --doctor
+npx ark-check --require-gates
+```
+
+Full copy-paste setups: [docs/ai-gates.md](../ai-gates.md).

package/docs/enthusiast/how-to-gallery-starter.md

@@ -0,0 +1,27 @@
+# How to use a gallery starter
+
+Gallery starters are minimal phase-1 scaffolds with a passing `ark-check --strict-config`.
+
+## Copy a starter
+
+```bash
+cp -R path/to/ark/examples/crud-product-starter/. .
+npm install
+npm run check
+```
+
+Pick by archetype — see [examples/README.md](../../examples/README.md).
+
+## When to use a starter vs hexagonal-order-api
+
+| Need | Use |
+|------|-----|
+| Fast baseline layout | `*-starter/` gallery |
+| Runnable API + break exercises | `hexagonal-order-api/` |
+
+## After copying
+
+1. Run `ark-check --doctor`
+2. Install gates: `ark-check --install-agent-gates`
+3. Use `/ark-place` for new files
+4. Optionally commit `ark-adoption-plan.json` from `--write-plan` alongside `ark.config.json`

package/docs/enthusiast/how-to-pick-shape.md

@@ -0,0 +1,45 @@
+# How to pick your application shape
+
+## Terminal
+
+```bash
+npx ark-check --recommend
+npx ark-check --recommend --json
+npx ark-check --recommend --write-plan   # also writes ark-adoption-plan.json
+```
+
+## MCP (agents)
+
+Call tool **`ark_recommend`** — same JSON as `--recommend --json`.
+
+## Skill
+
+Run **`/ark-architect`** on a greenfield or early-adoption repo.
+
+## What to read in the output
+
+| Field | Meaning |
+|-------|---------|
+| `archetype` | Application shape id (`crud-product`, `api-backend`, …) |
+| `preset` | Named Ark layout (`hexagonal`, `layered`, `feature-sliced`, `monorepo`) |
+| `confidence` | How sure the scorer is from repo signals |
+| `adoptInOrder.phase1` | Folders to create first |
+| `analogy` | Plain-language mental model |
+| `antiPatterns` | What Ark will block later |
+| `firstCommand` | Usually `ark init --archetype <id> --yes` |
+
+Framework names appear only as secondary `toolHints` in JSON — never as the archetype label.
+
+## Low confidence?
+
+If `confidence < 0.5`, ask:
+
+1. Will this app save data between sessions?
+2. Is this one app or several in one repository?
+
+Then re-run `--recommend` or continue with `/ark-architect`.
+
+## Reference
+
+Full archetype table: [reference-archetypes.md](reference-archetypes.md). Source of truth:
+`templates/architecture-playbook.json`.

package/docs/enthusiast/how-to-policy-pack.md

@@ -0,0 +1,37 @@
+# How to apply an enthusiast policy pack
+
+Policy packs are thin enthusiast variants over the same preset factories as `ark init --preset`.
+
+## List packs
+
+```bash
+npx ark-check --list-policy-packs
+npx ark-check --list-policy-packs --json
+```
+
+Available packs:
+
+- `enthusiast-hexagonal`
+- `enthusiast-layered`
+- `enthusiast-feature-sliced`
+- `enthusiast-monorepo`
+
+## Apply
+
+```bash
+npx ark-check --apply-policy-pack enthusiast-hexagonal
+npx ark-check --root . --config ark.config.json --strict-config
+```
+
+Use `--force` to overwrite an existing `ark.config.json`.
+
+Monorepo packs detect workspace roots from `package.json` / `pnpm-workspace.yaml` the same way `--init --preset monorepo` does.
+
+## Packs vs archetypes
+
+| You know… | Start with |
+|-----------|------------|
+| Application shape (todo app, API, …) | `ark-check --recommend` → `ark init --archetype` |
+| Preset name only | `--apply-policy-pack enthusiast-<preset>` |
+
+`ark-adoption-plan.json` from `--write-plan` includes a suggested `policyPack` id matching the recommended preset.

package/docs/enthusiast/reference-archetypes.md

@@ -0,0 +1,36 @@
+# Reference: archetypes and presets
+
+Authoritative source: `templates/architecture-playbook.json` (shipped in the npm package).
+
+## Archetypes (application shape)
+
+| Id | Shape | Default preset |
+|----|-------|----------------|
+| `crud-product` | UI + stored data | `hexagonal` |
+| `api-backend` | API server, no UI in repo | `hexagonal` |
+| `frontend-surface` | UI-heavy; backend elsewhere | `layered` / `feature-sliced` |
+| `library-sdk` | Publishable package | `layered` |
+| `cli-utility` | Command-line tool | `layered` |
+| `worker-pipeline` | Background jobs | `hexagonal` |
+| `event-coordinator` | Multi-step processes | `hexagonal` |
+| `integration-bridge` | System glue | `hexagonal` |
+| `multi-app-workspace` | Monorepo | `monorepo` |
+| `prototype-spike` | Quick experiment | `layered` |
+
+## Named presets
+
+| Preset | Policy pack |
+|--------|-------------|
+| `hexagonal` | `enthusiast-hexagonal` |
+| `layered` | `enthusiast-layered` |
+| `feature-sliced` | `enthusiast-feature-sliced` |
+| `monorepo` | `enthusiast-monorepo` |
+
+## Gallery mapping
+
+| Archetype | Starter |
+|-----------|---------|
+| `crud-product` | `examples/crud-product-starter/` |
+| `api-backend` | `examples/api-backend-starter/` |
+| `worker-pipeline` | `examples/worker-pipeline-starter/` |
+| `multi-app-workspace` | `examples/multi-app-workspace-starter/` |

package/docs/enthusiast/reference-commands.md

@@ -0,0 +1,50 @@
+# Reference: commands and artifacts
+
+## Recommendation
+
+```bash
+ark-check --recommend [--json] [--write-plan]
+```
+
+MCP: `ark_recommend` — same JSON body.
+
+## Adoption plan artifact
+
+`ark-adoption-plan.json` — optional committed record. Fields:
+
+- `archetype`, `preset`, `confidence`
+- `phases` (`1` | `2` | `3` layer lists) and `adoptInOrder.phase1|phase2|phase3`
+- `matchedSignals` — shape signals that drove the score
+- `analogy`, `antiPatterns`, `why`
+- `initCommand`, `firstCommand`, `recommendCommand`, `checkCommand`
+- `galleryStarter`, `policyPack`
+
+Never weakens the gate; JSON only.
+
+## Policy packs
+
+```bash
+ark-check --list-policy-packs [--json]
+ark-check --apply-policy-pack <id> [--force]
+```
+
+Pack metadata: `templates/policy-packs/enthusiast-*.json`.
+
+## Init and verify
+
+```bash
+ark init --archetype <id> --yes
+ark-check --doctor [--json]
+ark-check --coverage [--json]
+ark-check --strict-config
+ark-check --report out.html --beginner
+ark-check --watch
+```
+
+## Violation JSON (enthusiast fields)
+
+When present on violations:
+
+- `fixClass` — e.g. `port-inversion`, `file-move`
+- `effort` — `small` | `medium`
+- `enthusiastHint` — plain English fix guidance

package/docs/enthusiast/tutorial-first-project.md

@@ -0,0 +1,86 @@
+# Tutorial: your first Ark-governed project
+
+This tutorial walks one path end-to-end. You need Node 18+ and a new empty folder.
+
+## 1. Create the project
+
+```bash
+mkdir my-app && cd my-app
+npm init -y
+npm install -D arkgate typescript
+```
+
+## 2. Discover your application shape
+
+```bash
+npx ark-check --recommend
+```
+
+Read the **archetype** (application shape, not “Next.js” or “Prisma”), the **preset**,
+and **phase-1 layers**. If you are unsure, answer the two questions the agent skill
+may ask: “Will this save data?” and “Is this one app or several in one repo?”
+
+Optional machine-readable record:
+
+```bash
+npx ark-check --recommend --write-plan
+# -> ark-adoption-plan.json (safe to commit as a team adoption record)
+```
+
+## 3. Adopt the contract
+
+Non-interactive (recommended for scripts):
+
+```bash
+npx ark init --archetype crud-product --yes
+```
+
+Or apply an enthusiast policy pack directly:
+
+```bash
+npx ark-check --list-policy-packs
+npx ark-check --apply-policy-pack enthusiast-hexagonal
+```
+
+## 4. Scaffold phase-1 folders
+
+Create only the directories listed under phase 1 — for a CRUD product typically:
+
+```
+src/domain/
+src/application/
+src/presentation/   # or pages/, components/, http/
+src/adapters/       # persistence implementations
+```
+
+Or copy a [gallery starter](../enthusiast/how-to-gallery-starter.md) and run `npm install && npm run check`.
+
+## 5. Install agent gates
+
+```bash
+npx ark-check --install-agent-gates
+```
+
+This installs `/ark-architect`, `/ark-place`, `/ark-autopilot`, and the other `/ark-*` skills for Claude, Cursor, Codex, Grok, and other detected hosts.
+
+## 6. Verify honestly
+
+```bash
+npx ark-check --doctor
+npx ark-check --coverage
+npx ark-check --root . --config ark.config.json --strict-config
+```
+
+Report `governed.percent` truthfully. An empty layer is fine; an ungoverned `lib/` folder is not.
+
+## 7. Build a feature with the agent
+
+Invoke `/ark-architect` once at the start, then `/ark-place` for each new file. The agent
+should place use cases in `application/`, ports in `domain/`, and never import the database
+into `domain/`.
+
+## Next steps
+
+- [How to pick your shape](how-to-pick-shape.md)
+- [Public demos](../demos/)
+- [Brownfield adoption](../brownfield-adoption.md) if you already have code

package/docs/production-hardening.md

@@ -0,0 +1,59 @@
+# Production Hardening
+
+Ark's built-in stores are intentionally in-memory defaults. They are appropriate for tests,
+local development, examples, and single-process demos. Production systems should provide
+stores that match their durability, ordering, retention, and operational requirements.
+
+## In-Memory Defaults
+
+These defaults do not survive process restarts:
+
+- `InMemoryAuditStore`
+- `InMemoryOutboxStore`
+- `InMemoryReadModelStore`
+- `InMemoryWorkflowStore`
+
+Use them only when losing state is acceptable.
+
+## Production Store Checklist
+
+When implementing Ark store interfaces in production, cover these guarantees explicitly:
+
+- Durability: records survive process restarts and deploys.
+- Idempotency: repeated writes or dispatch attempts do not corrupt state.
+- Ordering: event/outbox ordering is defined where consumers depend on it.
+- Concurrency: simultaneous publishers/workers cannot race checkpoints or workflow state.
+- Retention: audit and trace records have an explicit retention policy.
+- Observability: failed writes and dispatches are visible to operators.
+- Migration: schema changes for stored records are versioned.
+
+## Interface Targets
+
+| Concern | Interface |
+|---------|-----------|
+| Audit records | `AuditStore` |
+| Outbox dispatch handoff | `OutboxStore` |
+| Projection state | `ReadModelStore` |
+| Workflow snapshots | `WorkflowStore` |
+
+## Example Shape
+
+```ts
+class DurableAuditStore implements AuditStore {
+  async append(record: AuditRecord): Promise<void> {
+    // Insert into your database with an idempotent key.
+  }
+
+  async query(query: AuditQuery = {}): Promise<AuditRecord[]> {
+    // Apply query filters and retention-aware ordering.
+    return [];
+  }
+
+  async clear(): Promise<void> {
+    // Usually only enabled in tests or isolated maintenance jobs.
+  }
+}
+```
+
+Ark does not ship a database adapter in core because storage choice is operationally
+specific. Keep those adapters in the application or a separate integration package.

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "arkgate",
+  "version": "2.1.0",
+  "description": "ArkGate — architecture co-pilot for AI TypeScript (write gate, CI gate, plan/loop)",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./eslint": {
+      "types": "./dist/eslint/index.d.ts",
+      "import": "./dist/eslint/index.js",
+      "require": "./dist/eslint/index.cjs"
+    },
+    "./nestjs": {
+      "types": "./dist/nestjs/index.d.ts",
+      "import": "./dist/nestjs/index.js",
+      "require": "./dist/nestjs/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "arkgate": "bin/ark.mjs",
+    "arkgate-check": "bin/ark-check.mjs",
+    "arkgate-mcp": "bin/ark-mcp.mjs",
+    "ark": "bin/ark.mjs",
+    "ark-check": "bin/ark-check.mjs",
+    "ark-mcp": "bin/ark-mcp.mjs"
+  },
+  "mcpName": "io.github.pedroknigge/arkgate",
+  "files": [
+    "bin",
+    "dist",
+    "docs/agent-guide.md",
+    "docs/enthusiast",
+    "docs/demos",
+    "docs/ai-gates.md",
+    "docs/ark-check-example.json",
+    "docs/assets",
+    "docs/brownfield-adoption.md",
+    "docs/production-hardening.md",
+    "templates",
+    "server.json",
+    "README.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "security:audit": "npm audit --omit=dev --audit-level=high",
+    "check:architecture": "node bin/ark-check.mjs --root . --config ark.config.json --strict-config",
+    "eval:agent": "node eval/run.mjs",
+    "eval:comparative": "node eval/comparative-run.mjs",
+    "clean": "rm -rf dist",
+    "release:npm": "node scripts/release-npm.mjs",
+    "prepack": "npm run build"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">=9"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": true
+    }
+  },
+  "overrides": {
+    "vite": "6.4.3",
+    "tsup": {
+      "esbuild": "0.28.1"
+    },
+    "bundle-require": {
+      "esbuild": "0.28.1"
+    }
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.1.27",
+    "@types/node": "^20.14.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.3",
+    "vitest": "^3.2.6"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "arkgate",
+    "architecture",
+    "architecture-gate",
+    "ai-agents",
+    "mcp",
+    "write-gate",
+    "hexagonal",
+    "clean-architecture",
+    "layered-architecture",
+    "import-rules",
+    "dependency-rules",
+    "boundaries",
+    "co-pilot",
+    "governance",
+    "typescript",
+    "eslint",
+    "nestjs",
+    "architecture-enforcement"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pedroknigge/ark-runtime-kernel.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}