kataster 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,82 @@
+# Changelog
+
+## 0.2.0 – 2026-10-31
+
+- **Renamed from La Guardia to Kataster.** The CLI is `npx kataster`, the state directory is `.kataster/`, the
+  managed block markers are `kataster:*`, the OpenCode adapter lives in `.opencode/plugins/kataster/`, the env var is
+  `KATASTER_NODE` and the default backlog label prefix is `kataster`. `upgrade` migrates an existing installation in
+  place (state directory, plugin path, markers in `AGENTS.md`/`CLAUDE.md`, `.gitignore`); `doctor` reports leftovers.
+  An existing `.claude/project.json` keeps its own `backlog.labelPrefix`, so labels already in GitHub or Jira stay
+  valid – rename them by hand if you want them to follow.
+
+- New `/shape` skill: the step between an idea and `/feature`. It grills a large idea, places it (existing or new
+  bounded context, shared library), maps change vs. new work, slices it, and produces a cost range with basis and
+  confidence. It creates no stories; the brief lives in `docs/product/initiatives/<slug>.md` and ends with one
+  recommendation (go / slice 1 / spike / discover / park / no-go). `--dry-run` writes nothing. A partially adopted
+  repository or an analogous service is used as evidence, never as a template.
+- `/feature` accepts a reference: `ST-NNN`, `#issue`, a Jira key or URL, or a Jira issue exported through MCP.
+  A read-only `feature/scripts/intake.ts` resolves it, finds the linked local story by id or `external`, and returns a
+  route – continue a draft, review, implement, treat finished behaviour as a new story, send a bug to a regression
+  story, or run the feature pipeline. The ticket is evidence, not a specification: criteria are grilled, the source
+  is recorded in the story, and `external` stays owned by the backlog sync.
+- Brownfield adoption in slices: `/adopt` now builds a deterministic repository map first
+  (`docs/architecture/repo-map.json`/`.md`), then adopts one domain plus at most one shared library per session.
+  The map knows packages, internal dependencies, consumers and an adoption ranking.
+- Monorepo tooling detection (Nx, Turborepo, Bazel, pnpm/npm/yarn workspaces, Go, Cargo, Gradle, Maven) in
+  `.claude/project.json` → `repo.tooling`; commands per package and affected tests use that tool.
+- Per-package docs: `<package>/AGENTS.md` (purpose, entities or public API, interfaces, pitfalls, boundaries) plus
+  a one-line `<package>/CLAUDE.md` importing it, so Claude Code and OpenCode load them only when working there.
+  The root `AGENTS.md` stays free of domain and keeps structure, commands and hard conventions.
+- An existing `CLAUDE.md` now gets the `@AGENTS.md` import without losing its house rules; without the import,
+  Claude Code would read only the project's own file and never load the workflow instructions.
+- Brownfield adoption no longer creates stories by default. It records a gap register in the adoption report;
+  `/adopt <scope> --stories` turns the selected gaps into a backlog when the user wants one.
+- The installer preserves project hooks under `.claude/hooks/` on upgrade; only its own exact hook commands are
+  replaced.
+- `verify.ts` warns when the generated repository map is stale.
+- Architecture boundaries as data: `docs/architecture/boundaries.yaml` (first matching `from` → `to` rule wins),
+  a JS/TS import scanner or a `command` engine for dependency-cruiser, Nx, Bazel, ArchUnit, import-linter, and
+  `docs/architecture/boundaries.baseline.json` for baseline/ratchet. `--init` writes a proposal; existing
+  violations are frozen; only new ones fail.
+- `docs/engineering/checks.yaml` and the `project-check.ts` dispatcher: project-owned checks run at edit time
+  (changed file only) and at Stop/CI. Wired once in Claude Code and OpenCode, never per package.
+- `rule-doc.ts` scaffolds and validates `.claude/rules/*.md` with `paths:` frontmatter; directory rules stay in
+  `<dir>/AGENTS.md` so both harnesses load them on demand.
+- Turborepo tool graph: `repo-map.ts` asks `turbo run <task> --dry=json` for the real package/task edges and stores
+  them as an optional `toolGraph`; without Turbo it falls back to manifests. `affected.ts` maps changed files (or
+  `--base`) to affected packages, follows dependents of shared libraries, and emits the native Turbo/Nx/Bazel/pnpm
+  command; `--run` executes it. `/implement` uses it for the fast loop, `verify.ts` remains the full gate.
+- Nx and Bazel tool graphs: `nx graph --file=<temp>` is resolved to package names (Nx project names need not match,
+  e.g. `billing` vs `@acme/billing`) and kept in `toolGraph.projectNames` so `affected.ts` emits
+  `nx run-many -p billing,…`; Bazel packages and edges come from the `deps` attributes in `BUILD`/`BUILD.bazel`,
+  so no Bazel server or toolchain is needed. Both stay enrichment: no tool, no graph, manifest fallback.
+- Path-scoped rules in both harnesses: `.claude/rules/*.md` stays the single source of truth, Claude Code scopes
+  it natively by `paths:`, and the OpenCode plugin calls the new `path-rules.ts` hook whenever a file is read or
+  written to attach each matching rule once per session as a keyed instruction entry. The rule body is sent
+  without its frontmatter; the scope is stated in the first line.
+- Backlog backends: stories can stay local (default), live in GitHub Issues (`gh`) or in Jira (`mcp-atlassian`).
+  With a tracker, `docs/stories/` is a synchronized local mirror, `ST-NNN` stays the stable id and the tracker key
+  lives in `external`. Only the backlog core syncs; reviews and open questions stay local.
+- New `backlog` skill and `/backlog-sync` command: status, pull and push, with conflict detection, backups and a
+  three-way sync state. GitHub syncs deterministically; Jira is driven through MCP with plan/record/import scripts.
+- `kataster init --backlog local|github|jira`, provider config in `.claude/project.json`, `doctor` checks for `gh`,
+  the Jira project and the MCP server.
+- Story schema and validator understand `external` and refuse a `ready`/`in-progress`/`done` mirror story without a
+  tracker link.
+
+## 0.1.0 – 2026-10-29
+
+First standalone release.
+
+- `kataster init | upgrade | doctor` with stack detection, project profile and idempotent install
+- Merges into existing `AGENTS.md`, `.claude/settings.json`, `.opencode/opencode.jsonc` and `.gitignore`
+- Greenfield entry point `/bootstrap`: vision grilling → event storming → domain model → architecture → UX →
+  foundation stories
+- Brownfield entry point `/adopt`: five parallel `repo-analyst` lenses → evidence-based domain draft → grilling →
+  gap stories
+- `repo-analyst` agent (read-only) for OpenCode and Claude Code
+- Project profile `.claude/project.json` replaces hardcoded project assumptions; `verify.ts` runs its commands
+- `docs/engineering/conventions.md` replaces the project-specific conventions skill; the original is kept in
+  `examples/` as a reference
+- Optional `shadcn` skill moved to `extras/` (`--with shadcn`)
+- Guardrails generalized: deploy providers, database tools, default branch from the profile

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kataster contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,325 @@
-# Temporary Holding Version
+# Kataster
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**An agent workflow for domain-driven discovery and delivery.** Drop it into a repository, and the agent builds the
+domain with you – by grilling, not by guessing – then carries it through stories, test-first implementation and
+review.
+
+The name is the German word for the official register of land parcels and their boundaries – a map that is
+maintained, not invented. The domain model is that register: bounded contexts are the parcels, the glossary and the
+data model are the entries, and nothing goes in without evidence.
+
+Works in two situations:
+
+- **Brownfield** – the repository already has code. `/adopt` analyses code, docs, tests, schema and git history,
+  drafts the domain model with evidence, and grills you to correct it. No rewrite, no invented domain.
+- **Greenfield** – nothing but an idea. `/bootstrap` grills the vision, runs an event storming, builds contexts,
+  aggregates, the data model and the ADRs, and derives the foundation stories and first vertical slice.
+
+The same workflow then handles every large idea (`/shape`), every feature (`/feature`), every story review
+(`/review-stories`), implementation (`/implement`) and backlog care (`/groom-backlog`, `/retro`).
+
+```bash
+npx kataster init
+```
+
+That is the whole installation. It writes `.claude/`, `.opencode/`, `AGENTS.md` and a `docs/` skeleton into the
+current repository, detects the stack, and asks four questions – the last one is whether stories stay local or live
+in GitHub Issues or Jira (and if so, for the project or repository).
+
+---
+
+## Why this exists
+
+Agents are good at writing code and bad at knowing what the words mean. A repository without a domain model produces
+code that is locally plausible and globally inconsistent: three names for one concept, rules enforced only in the UI,
+features nobody can place. Kataster makes the domain a first-class artifact – glossary, events, contexts,
+aggregates, invariants – and makes the agent earn every statement in it from the user or from evidence.
+
+Two rules run through everything:
+
+1. **Facts are the agent's job, decisions are the user's.** The agent looks things up; it never invents a domain
+   term, a rule or a boundary.
+2. **The user confirms, the agent writes.** Grilling works in rounds on the *frontier*: every question whose
+   prerequisites are settled, each with a recommended answer. Nothing is assumed silently.
+
+## Requirements
+
+- Node.js **22.18+** (the tooling runs TypeScript directly, no build step)
+- Git
+- An agent harness: **OpenCode** or **Claude Code**
+- Optional: `gh` for pull requests and a GitHub Issues backlog, the `mcp-atlassian` MCP server for a Jira backlog,
+  a preview provider (Vercel, Netlify, …) for acceptance testing
+
+## Quick start
+
+```bash
+# existing repository
+npx kataster init --brownfield
+# new project
+npx kataster init --greenfield
+# stories in GitHub Issues or Jira
+npx kataster init --backlog github --github-repo acme/shop
+npx kataster init --backlog jira --jira-project PROJ
+```
+
+Then open the repository in your agent harness and run `/adopt` or `/bootstrap`.
+
+Non-interactive (CI, scripts):
+
+```bash
+npx kataster init . --yes --name "Acme" --ui-language de --artifacts en
+```
+
+## What gets installed
+
+```
+.claude/
+  project.json          project profile – name, stack, languages, commands, backlog backend (edit this)
+  skills/               the workflow skills (grilling, event-storming, domain-model, architect, backlog, …)
+  skills/adopt/scripts/ repository map and per-package docs for brownfield adoption
+  skills/feature/scripts/ read-only intake: story, GitHub/Jira ticket or URL → route
+  agents/               review agents for Claude Code
+  hooks/                plain-Node guardrails and validators
+  lib/                  deterministic domain/story/backlog logic
+.opencode/
+  commands/             the slash commands
+  agents/               the same agents for OpenCode
+  plugins/kataster/ adapter that runs the .claude hooks in OpenCode
+AGENTS.md               short entry point for every session (merged, never clobbered)
+CLAUDE.md               imports AGENTS.md for Claude Code (created, or the import added to an existing file)
+CONTEXT.md              the glossary – starts as a template
+docs/
+  workflow.md           the map: sources of truth, commands, phases, rules
+  product/vision.md     the vision, grilled with you
+  product/initiatives/  proposals for large ideas from /shape (no stories)
+  domain/events.yaml    the event storming model (empty is valid)
+  domain/context-map.md
+  architecture/data-model.md
+  architecture/repo-map.*      generated by /adopt: packages, edges, adoption ranking
+  engineering/conventions.md   how this repo builds code + the seam catalog
+  stories/              the backlog – or the local mirror of GitHub/Jira
+  adr/                  architecture decisions
+  reviews/              story reviews and adoption reports
+```
+
+Existing `AGENTS.md`, `.claude/settings.json` and `.opencode/opencode.jsonc` are **merged**, not overwritten.
+Existing `CONTEXT.md` and `docs/` are never touched.
+
+## The commands
+
+| Command | What it does |
+|---|---|
+| `/adopt [scope] [--stories]` | Brownfield: repository map → one slice (domain + shared library) → evidence → grilling → package docs and checks → gap register; stories only with `--stories`; repeat per slice |
+| `/bootstrap` | Greenfield: vision → event storming → domain model → architecture → UX → foundation stories |
+| `/grill-me` | Relentless interview on a plan, decision or idea |
+| `/grill-with-docs` | The same, writing glossary and ADRs as you go |
+| `/event-storming [process]` | Big-picture or single-process event storming |
+| `/feature <idea \| ST-NNN \| #123 \| PROJ-123>` | New feature from an idea, an existing story or a ticket: intake and routing, grilling, focused storming, model, stories, review; bugs become a regression story |
+| `/shape <idea \| ticket> [--dry-run]` | Before a large feature: frame, place (existing/new context, shared library), impact, slices, rough cost range, recommendation; creates no stories |
+| `/review-stories [ST-…]` | One lead-dev pass (value, build, UX) before a story is `ready` |
+| `/backlog-sync [status\|pull\|push]` | Keep `docs/stories/` in sync with GitHub Issues or Jira |
+| `/groom-backlog [scope]` | Periodic challenge: is this backlog still worth building? |
+| `/implement [ST-NNN]` | Test-first implementation of one story, review, refactor, PR |
+| `/improve-codebase-architecture` | Scan for deepening opportunities, present them, grill one |
+| `/retro` | Retrospective on a session, proposing rule changes |
+
+### Starting from a ticket
+
+`/feature` also accepts a reference: `/feature #123` (GitHub), `/feature PROJ-123` (Jira, with the issue fetched
+through MCP), `/feature https://…` or `/feature ST-042`. A read-only intake resolves it and returns a route: an
+existing `draft`/`review` story is revised, a `ready`/`in-progress` one goes to `/implement`, a finished one becomes a
+new story, and a bug becomes one regression story instead of a feature. The ticket is **evidence, not a
+specification** – its acceptance criteria are grilled, contradictions with the model are findings, and the source is
+recorded in each story. `external` is still written only by the backlog sync.
+
+### Shaping a large idea
+
+`/shape` is the step between an idea and `/feature`. It grills the problem, decides where the work belongs – an
+existing bounded context, a new one, or a shared library – maps what changes vs. what is built new, proposes 2–5
+slices, and gives a rough **cost range with confidence and basis**. It ends with one recommendation: go, go with
+slice 1, spike first, needs discovery, park or no-go. It creates **no stories**; each slice goes to `/feature`.
+
+```bash
+/shape "shop products with variants and channel prices"
+/shape PROJ-123
+/shape --dry-run "a new service next to the existing one"   # test the method, write nothing
+```
+
+The brief lands in `docs/product/initiatives/<slug>.md` (`proposed` until you accept it). A new service in an
+existing monorepo is treated as a new context in an existing landscape, not as a greenfield project; a similar
+service is used as evidence and as the cost anchor, never as a template.
+
+## Greenfield, end to end
+
+1. `npx kataster init --greenfield` → review `.claude/project.json`.
+2. `/bootstrap` → vision grilled, event storming, contexts/aggregates/data model, tech-stack ADR, UX guidelines.
+3. `/review-stories` → the first foundation tech tasks and the first vertical slice become `ready`.
+4. `/implement` → one story at a time, test-first, reviewed, merged by you.
+5. `/feature <idea>` for everything after that.
+
+## Brownfield, end to end
+
+1. `npx kataster init --brownfield` → the profile is filled from the detected stack and monorepo tooling
+   (`repo.tooling`: Nx, Turborepo, Bazel, workspaces, Go, Cargo, Gradle, Maven).
+2. `/adopt` → a deterministic **repository map** (`docs/architecture/repo-map.md`, `.json`) with packages,
+   dependency edges, consumers and an adoption ranking. No questions, no hand-scanning.
+3. `/adopt [scope]` → **one slice** (one domain plus at most one shared library): two or three `repo-analyst`
+   subagents return evidence (five lenses for a small single-package repository); the main session drafts `CONTEXT.md`, `events.yaml`, context map, as-is data model,
+   conventions and de-facto ADRs; it writes `<package>/AGENTS.md` + `<package>/CLAUDE.md`, then grills you.
+4. The safety net turns confirmed rules into checks (types, lint/boundary, tests, hooks) – report-only with a
+   baseline first, so a brownfield repository does not start red.
+5. The gap analysis records **contradictions, missing behaviour and dead code** in the adoption report. It creates
+   **no stories by default** – what already works is documented, not re-storied. `/adopt <scope> --stories` turns
+   the selected gaps into a backlog when you want one.
+6. `/adopt <next path>` for the next slice; `/adopt <scope> --stories`, `/review-stories`, then `/implement`.
+
+Adopt in slices: one bounded context completely beats the whole repository shallowly. The root `AGENTS.md` stays
+free of domain; the package docs are loaded only when someone works in that package.
+
+## Monorepos
+
+The installer detects the build tool (Nx, Turborepo, Bazel, pnpm/npm/yarn workspaces, Go, Cargo, Gradle, Maven)
+and stores it in `.claude/project.json` → `repo.tooling`. `/adopt` builds the repository map once, then adopts
+**one domain plus at most one shared library per session**. Every adopted package gets an `AGENTS.md` with its
+purpose, entities or public API, interfaces and pitfalls – plus a one-line `CLAUDE.md` so Claude Code loads it on
+demand; OpenCode loads the nested `AGENTS.md` itself. The root `AGENTS.md` stays short and free of domain.
+
+Commands use the detected tool instead of assuming a single package: `nx affected -t test`,
+`turbo run test --filter=<package>`, `bazel test //<package>/...`, `pnpm --filter <package> test`. The map also
+stores the tool's own graph – Turborepo via `turbo run <task> --dry=json`, Nx via `nx graph`, Bazel from the
+`BUILD` deps – and `affected.ts` turns changed files into the affected packages plus the native filter command,
+following shared-library dependents:
+
+```bash
+node .claude/skills/implement/scripts/affected.ts --changed libs/shared-kernel/src/index.ts
+node .claude/skills/implement/scripts/affected.ts --base origin/main
+```
+
+## The project profile
+
+`.claude/project.json` is the single place for project facts. Skills, hooks and scripts read it instead of assuming
+`main`, `npm` or a language.
+
+```jsonc
+{
+  "name": "Acme",
+  "kind": "brownfield",
+  "languages": { "artifacts": "en", "ui": "de" },
+  "stack": { "summary": "TypeScript, Next.js, PostgreSQL" },
+  "repo": {
+    "defaultBranch": "main",
+    "codeRoots": ["apps", "libs"],
+    "tooling": {
+      "kind": "nx",
+      "config": "nx.json",
+      "workspaces": ["apps/*", "libs/*"],
+      "manager": "pnpm",
+      "monorepo": true
+    }
+  },
+  "commands": { "lint": "npm run lint", "typecheck": "npm run typecheck", "test": "npm test" },
+  "review": { "preview": "vercel", "pullRequest": "gh" },
+  "backlog": {
+    "provider": "local",
+    "github": { "repo": "", "labelPrefix": "kataster" },
+    "jira": {
+      "mcpServer": "mcp-atlassian",
+      "project": "PROJ",
+      "issueType": "Story",
+      "statusMap": { "draft": "To Do", "ready": "Ready", "done": "Done" },
+      "priorityMap": { "must": "Highest", "should": "High" }
+    }
+  }
+}
+```
+
+`verify.ts` runs exactly these commands. `/adopt` fills them from the code; edit them if the detection is wrong.
+
+## Backlog backends
+
+Stories live in one of three places, chosen at install with `--backlog` and stored in `.claude/project.json`:
+
+| Provider | Source of truth | Transport |
+|---|---|---|
+| `local` (default) | `docs/stories/` | the Markdown files |
+| `github` | GitHub Issues | `gh` CLI – deterministic, works from scripts |
+| `jira` | Jira | `mcp-atlassian` – MCP is agent-only |
+
+With a tracker, **the tracker leads** and `docs/stories/` is a synchronized local mirror. That keeps the deterministic
+parts – validation, `BACKLOG.md`, scenario ↔ test traceability, `next-story` – working offline, while the team works in
+the tracker.
+
+- Each story keeps its stable `ST-NNN` id; the tracker key lives in `external: { provider, key, url }`. Test titles do
+  not change.
+- Only the backlog core syncs: story content, status, priority, size, risk, context, type, dependencies and labels.
+  Reviews and `OPEN_QUESTIONS.md` stay local.
+- A story must be linked before it reaches `ready` – the validator refuses an unlinked mirror story.
+- On a conflict the tracker wins; the local file is backed up to `.kataster/backup/backlog/` first. GitHub's `push`
+  refuses a story whose remote side changed; the Jira plan cannot see Jira, so pull before planning a push.
+- GitHub issues are closed for `done`/`superseded`; Jira uses the configured status names and transitions.
+
+```bash
+node .claude/skills/backlog/scripts/backlog-status.ts   # what is linked, what drifted
+node .claude/skills/backlog/scripts/backlog-push.ts     # mirror → tracker (GitHub)
+node .claude/skills/backlog/scripts/backlog-pull.ts     # tracker → mirror (GitHub)
+```
+
+For Jira, `jira-plan.ts` prints the exact MCP calls, `jira-record.ts` writes the returned keys back, and
+`backlog-pull.ts --from issues.json` imports what the agent fetched through MCP. The `backlog` skill has the full flow.
+
+## Quality gates
+
+- **Hooks** validate `docs/domain/events.yaml` and stories after every write, format and lint changed code, block
+  edits to generated files and accepted ADRs, and stop force pushes, production deploys and destructive database
+  commands.
+- **Path-scoped rules** live in `.claude/rules/*.md` with `paths:` frontmatter – for patterns a directory cannot
+  express. Claude Code loads them natively; in OpenCode the plugin attaches the matching rule to the session as
+  soon as a file under its globs is read or written, so one file serves both harnesses.
+- **Architecture boundaries** are data: `docs/architecture/boundaries.yaml` lists allowed/forbidden edges (first
+  match wins), `boundary-check.ts` enforces them, and `boundaries.baseline.json` freezes existing debt so only
+  new violations fail. `docs/engineering/checks.yaml` decides what runs at edit time and at Stop/CI; the
+  `project-check.ts` dispatcher is wired once, not per package.
+
+  ```bash
+  node .claude/skills/adopt/scripts/boundary-check.ts --init
+  node .claude/skills/adopt/scripts/boundary-check.ts            # fail on new violations
+  node .claude/skills/adopt/scripts/boundary-check.ts --update-baseline
+  ```
+- **`verify.ts`** is the one gate: project checks, artifact validity, scenario ↔ test traceability, domain IDs in
+  the code, glossary language.
+- **Review agents** never write code: `code-reviewer` and `acceptance-tester` report, the acceptance verdict decides
+  whether a story is `done`.
+
+## Upgrading
+
+```bash
+npx kataster upgrade
+npx kataster doctor
+```
+
+`upgrade` replaces workflow files, keeps project content (`CONTEXT.md`, `docs/`, `project.json`) and refuses to
+overwrite files you changed locally – it lists them instead. `--force` overwrites and writes a backup to
+`.kataster/backup/`.
+
+## Optional extras
+
+- `--with shadcn` installs the shadcn/ui skill for projects that use it.
+
+## Design notes
+
+- **`.claude/` is the source of truth.** OpenCode and Claude Code share skills, agents and hooks; `.opencode/` is an
+  adapter, not a second workflow.
+- **Plain Node, no build step.** Hooks and validators run on Node 22.18+ with one runtime dependency (`yaml`).
+- **Generated files stay generated.** `BACKLOG.md` and `event-storming.md` are rendered; edit the sources.
+- **The backlog is local by default.** One Markdown file per story; no issue tracker required. GitHub Issues and Jira
+  are opt-in, and `docs/stories/` stays the mirror that validation and traceability run on.
+
+## Name
+
+The name is a historical reference, not a domain: the workflow has none of its own. Everything project-specific
+was removed when the package was extracted – the examples are neutral, the stack is detected, and the language is
+yours.
+
+## License
+
+MIT

package/bin/kataster.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "../src/cli.mjs";
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});