living-ai-documentation 1.0.0

package/dist/starter-doc/AI/2026_01_01_how_to.md

@@ -0,0 +1,112 @@
+# How This AI Context Works
+
+This project was initialized by the Living Documentation wizard.
+
+The wizard already created the documentation folder and copied this starter.
+
+It also copied the AI entry files to the parent folder of the documentation folder when the target files did not exist or were empty:
+
+```text
+AGENTS.md
+CLAUDE.md
+memory/MEMORY.md
+```
+
+If one of these files already existed with content, the wizard stopped instead of overwriting it.
+
+Finally, it exposed these files inside Living Documentation through symbolic links:
+
+```text
+<docs-folder>/AI/AGENTS.md -> <project-root>/AGENTS.md
+<docs-folder>/AI/CLAUDE.md -> <project-root>/CLAUDE.md
+<docs-folder>/AI/MEMORY.md -> <project-root>/memory/MEMORY.md
+```
+
+In other words, these links do not point to another file inside the documentation folder. They expose, under `AI/`, the real files used by agents at the project root.
+
+The internal `AI/default/` template folder is removed from the initialized documentation after these copies and links are created.
+
+## What The Files Do
+
+`AGENTS.md` is the entry point for Codex and agent-style tools.
+
+`CLAUDE.md` is the entry point for Claude.
+
+`memory/MEMORY.md` is the project-local memory index.
+
+`AI/PROJECT-INSTRUCTIONS.md` is the shared operating guide for every AI assistant working on the project.
+
+`AI/PROJECT-STACK.md` describes the stack, useful source tree, core concepts, and structural conventions of the project.
+
+`AI/PROJECT-USEFUL-COMMANDS.md` lists the commands that are actually useful to install, run, test, verify, and maintain the project.
+
+`AI/rules/*.md` contains reusable rules that AI assistants must apply when they touch matching files.
+
+`ADRS/*.md` contains durable decisions. ADRs explain why the project works a certain way.
+
+## First-Run Verification
+
+Open the **AI Context** page from the main navigation.
+
+This page should let you verify:
+
+- that `AGENTS.md`, `CLAUDE.md`, and `memory/MEMORY.md` appear as documents under `AI/`;
+- that `PROJECT-INSTRUCTIONS.md`, `PROJECT-STACK.md`, and `PROJECT-USEFUL-COMMANDS.md` are visible and adapted to your project;
+- that AI rules are visible under `AI/rules/`;
+- that the MCP explorer shows the `living-ai-documentation` server, the `/mcp` endpoint, the available tools, and the prompts.
+
+If the MCP explorer does not show tools, the AI assistant cannot use Living Documentation as an active source of truth. It can still propose documentation changes, but it must state that metadata and hashes could not be updated through MCP.
+
+## Expected AI Workflow
+
+An AI assistant should:
+
+1. Read its entry point: `AGENTS.md` or `CLAUDE.md`.
+2. Follow the link to `AI/PROJECT-INSTRUCTIONS.md`.
+3. Read `AI/PROJECT-STACK.md` to understand the technical choices, useful source tree, and project concepts.
+4. Read `AI/PROJECT-USEFUL-COMMANDS.md` to use the right commands instead of guessing them.
+5. Read `memory/MEMORY.md` and load only relevant memory files.
+6. Read the matching rules in `AI/rules/*.md`.
+7. Inspect ADR frontmatter when a task may touch an existing decision.
+8. Make the requested change.
+9. At the end of a coherent feature, update durable documentation when needed.
+10. Update `PROJECT-STACK.md` or `PROJECT-USEFUL-COMMANDS.md` if the task makes their content wrong, incomplete, or obsolete.
+11. Attach Living Documentation metadata to created or updated documents when source files prove their content.
+
+## Project Instructions
+
+The shared instructions are in:
+
+```text
+AI/PROJECT-INSTRUCTIONS.md
+```
+
+## ADRs
+
+The starter includes an ADR example:
+
+```text
+ADRS/2026_01_01_[ADR]_example_architecture_decision.md
+```
+
+Use it as a template when a significant decision must be recorded.
+
+An ADR is appropriate when a change affects architecture, a public contract, a storage format, a workflow, a protocol, or a durable convention. It is not needed for trivial fixes or implementation details that are obvious from code.
+
+## Metadata And Reliability
+
+Living Documentation can bind a document to source files. Each binding stores a hash of the source file so the reliability gauge can show whether the document may have drifted from the code.
+
+When an AI creates or updates an ADR or technical document, it should attach the source files that prove or implement the document. If MCP tools are available, prefer `add_metadata` and `refresh_metadata`.
+
+If metadata cannot be updated from the current environment, the AI should say so and list the files that should be attached manually.
+
+## Cleanup
+
+After setup, remove only what is not useful for your project.
+
+Common cleanup:
+
+- keep this document if future contributors should understand the initialized structure;
+- adapt `PROJECT-STACK.md` and `PROJECT-USEFUL-COMMANDS.md` as soon as the first real project commands and conventions are known;
+- keep the ADR example only if you want an in-project template.

package/dist/starter-doc/AI/PROJECT-INSTRUCTIONS.md

@@ -0,0 +1,172 @@
+# PROJECT-INSTRUCTIONS - Living Documentation
+
+This file is the shared working contract for AI assistants working on this project. It explains how to integrate Living Documentation into the AI-assisted development workflow.
+
+`AGENTS.md` and `CLAUDE.md` are tool-specific entry points. They should stay short and point to this file, which carries the common rules.
+
+## Startup Routine
+
+Before changing the project:
+
+1. Read `AGENTS.md` or `CLAUDE.md`, depending on the tool.
+2. Read this file: `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
+3. Read `DOCS_FOLDER/AI/PROJECT-STACK.md` to understand the stack, useful source tree, core concepts, and structural conventions.
+4. Read `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` to know the development, build, test, lint, and setup commands.
+5. Read `memory/MEMORY.md` and load only the memory files relevant to the task.
+6. Read every rule in `DOCS_FOLDER/AI/rules/*.md`.
+7. Read `DOCS_FOLDER/WORKLOG/current-task.md` if present to resume the state of the current task.
+8. Inspect existing ADRs: list `DOCS_FOLDER/ADRS/`, read only `description` and `tags` first, then open the full ADR only when relevant.
+9. Check whether the Living Documentation MCP server is available before creating or modifying documentation.
+
+## Living Documentation MCP
+
+The Living Documentation MCP is the preferred channel for reading, creating, and maintaining project documentation. When it is available, the AI must use it instead of editing Markdown files by hand.
+
+Use in particular:
+
+- `list_documents` to discover existing documents;
+- `read_document` to read a document source;
+- `create_document` or `update_document` to create or correct a document;
+- `list_source_files`, `read_source_file`, and `search_source` to connect documentation to code;
+- `add_metadata` to attach a document to the source files that prove it;
+- `refresh_metadata` to recalculate hashes after updates;
+- `get_accuracy` or equivalent tools to detect drift between documentation and code.
+
+If the MCP is not available, the AI may propose documentation changes, but it must explicitly state that metadata and hashes could not be updated.
+
+## Continuous Documentation
+
+Documentation is not a separate step to do later. It is part of the normal AI-assisted development workflow.
+
+At the end of every coherent feature, meaningful refactor, behavioral change, or durable decision, the AI must decide whether documentation should be updated.
+
+Create or update a document when the change:
+
+- modifies an architecture boundary;
+- introduces or changes a public contract;
+- changes a storage format, protocol, or workflow;
+- adds a convention future changes must follow;
+- makes an existing document incomplete, ambiguous, or wrong;
+- resolves a trade-off that would be hard to infer from code alone.
+
+Do not create durable documentation for trivial fixes, mechanical renames, or formatting-only changes.
+
+## Progress Tracking
+
+The `DOCS_FOLDER/WORKLOG/` folder holds the operational state of in-progress tasks and the resume points between AI assistants. It does not replace ADRs.
+
+`DOCS_FOLDER/WORKLOG/current-task.md` is the shared resume point. Every assistant must read it before resuming a task and update it before handing over when it has started, finished, interrupted, or left a known follow-up.
+
+The worklog must stay factual and useful for the next agent:
+
+- current status;
+- task in progress;
+- in-scope and out-of-scope items if needed;
+- files or areas concerned;
+- verifications performed;
+- remaining verifications;
+- next recommended action.
+
+Create a dedicated document under `DOCS_FOLDER/WORKLOG/` for an MVP ticket when more detailed tracking becomes necessary. Durable decisions stay in ADRs.
+
+## ADRs
+
+ADRs are the log of architecture and design decisions. They should stay short, traceable, and useful for deciding what to change later.
+
+When a feature changes a durable decision:
+
+1. Search for existing ADRs about the same topic.
+2. If an ADR remains valid, complete or correct it.
+3. If an ADR is replaced, mark it with the exact status `SuperSeeded` or `Partially SuperSeeded` and create a new ADR explaining the new decision.
+4. Never delete a replaced ADR: the history is useful.
+5. In the new ADR, explicitly mention the replaced ADR and why it is no longer enough.
+
+The recommended initial status for an AI-created ADR is `To be validated`. A human can later validate it and change it to `Accepted`.
+
+Each ADR should include frontmatter useful for discovery:
+
+```markdown
+---
+**date:** YYYY-MM-DD
+**status:** To be validated
+**description:** One sentence summarizing the decision and why it matters.
+**tags:** architecture, mcp, metadata
+---
+```
+
+## Metadata And Reliability Gauge
+
+A Living Documentation document should be linked to the source files that prove what it says. These links are stored as metadata and allow the document reliability score to be calculated.
+
+When the AI creates or updates an ADR or technical document:
+
+1. Identify the source files that are actually involved.
+2. Attach those files to the document with `add_metadata`.
+3. Avoid attaching overly generic files when a more precise file proves the content better.
+4. After correcting the document, call `refresh_metadata` to recalculate hashes.
+5. If a document remains correct after a cosmetic code change, use `refresh_metadata` to re-baseline the hash without rewriting the document unnecessarily.
+
+Metadata is not optional for documents that describe code. If metadata cannot be updated, the AI must say so in its final response and list the files that should be attached.
+
+## Project Stack And Commands
+
+`DOCS_FOLDER/AI/PROJECT-STACK.md` contains the operational project summary: technical stack, important source areas, core concepts, and structural conventions.
+
+`DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` contains commands that are actually useful: installation, local development, build, tests, lint, formatting, setup, and dangerous commands.
+
+These two files are living documentation. The AI must propose updates when a task makes their content false, incomplete, or insufficiently precise.
+
+Rules:
+
+- keep these files short, concrete, and action-oriented;
+- do not duplicate ADRs in them;
+- point to ADRs when a durable explanation exists;
+- verify that a command exists before documenting it;
+- do not silently change a structural convention or dangerous command: explain the change and wait for validation when the risk is significant.
+
+## AI Rules
+
+Rules live in `DOCS_FOLDER/AI/rules/*.md`.
+
+Each rule uses frontmatter:
+
+- `id` - stable identifier;
+- `title` - short human-readable name;
+- `severity` - `guideline`, `warning`, or `required`;
+- `description` - concise summary;
+- `tags` - themes used for discovery;
+- `appliesTo` - globs describing where the rule applies.
+
+Apply every rule whose `appliesTo` patterns match files you touch. If a rule conflicts with the user request or another project instruction, state the conflict explicitly before proceeding.
+
+## Memory
+
+Memory files live in the project under `memory/`.
+
+Do not store project memory in a tool-specific global folder if the user expects project-local memory. Update `memory/MEMORY.md` whenever memory files are added or removed.
+
+Memory is for stable, frequently reused context. Durable decisions should instead be written as ADRs.
+
+## Changing AI Instruction Files
+
+The AI may propose changes to `AGENTS.md`, `CLAUDE.md`, `PROJECT-INSTRUCTIONS.md`, `PROJECT-STACK.md`, `PROJECT-USEFUL-COMMANDS.md`, `memory/MEMORY.md`, or rules in `AI/rules/`.
+
+But these files directly steer AI assistant behavior. Before changing them, the AI must:
+
+1. explain to the user what it wants to change;
+2. explain why the change improves the workflow;
+3. state any possible risks;
+4. wait for explicit validation if the change may reduce visibility, remove a rule, weaken a constraint, or make the agent more autonomous.
+
+No destructive change to these files should be made silently.
+
+## Verification
+
+Before finishing a task, run the smallest useful verification:
+
+- build command if typed code or build files changed;
+- focused tests if behavior changed;
+- lint or formatting command if the project has one;
+- MCP/documentation verification if ADRs or metadata were created or modified.
+
+If a verification cannot be run, explain why.

package/dist/starter-doc/AI/PROJECT-STACK.md

@@ -0,0 +1,77 @@
+# PROJECT-STACK - Template
+
+This file gives the AI assistant a short, factual overview of the project. It must stay concise, concrete, and continuously maintained.
+
+It does not replace ADRs: it helps the assistant quickly know where to look, which technologies are involved, and which concepts structure the code. For the detailed reason behind a decision, read the relevant ADRs.
+
+## Maintenance Rule
+
+The AI must propose an update to this file when a task:
+
+- introduces, removes, or replaces an important technology;
+- changes a structural convention;
+- adds or moves an important source area;
+- changes a central business or technical concept;
+- makes any information below false or incomplete.
+
+Do not document volatile details, temporary TODOs, or information that clearly belongs in an ADR.
+
+## Overview
+
+Replace this paragraph with a short project description:
+
+- what the project does;
+- who it is for;
+- where the application code, documentation, and main entry points live.
+
+## Technical Stack
+
+Fill only the lines that actually exist in the project. Remove irrelevant categories.
+
+- **Main language**:
+- **Runtime**:
+- **Frontend framework**:
+- **Backend / server framework**:
+- **Database / storage**:
+- **External APIs / integrations**:
+- **Authentication / authorization**:
+- **Styles / design system**:
+- **State management**:
+- **Build / bundler**:
+- **Package manager**:
+- **Tests**:
+- **Lint / formatting**:
+- **Observability / logs**:
+- **Deployment / hosting**:
+
+## Useful Source Tree
+
+Describe the folders or files the AI must know to orient itself quickly.
+
+```text
+src/                 <- main application code
+tests/               <- automated tests
+documentation/       <- Living Documentation folder, if this is the project docs folder
+```
+
+Adapt this tree to the real project. Do not list the whole repository: keep only what helps an AI find where to work.
+
+## Core Concepts
+
+List concepts that often come up in tasks.
+
+- **Concept 1**: explain in one sentence and point to the useful ADR or document.
+- **Concept 2**: explain in one sentence and point to the useful ADR or document.
+- **Concept 3**: explain in one sentence and point to the useful ADR or document.
+
+## Structural Conventions
+
+List conventions the AI must respect before changing code.
+
+- Naming convention:
+- Module organization:
+- Error handling:
+- Configuration handling:
+- Test strategy:
+
+If a convention becomes durable or comes from an important trade-off, create or update an ADR instead of overloading this file.

package/dist/starter-doc/AI/PROJECT-USEFUL-COMMANDS.md

@@ -0,0 +1,80 @@
+# PROJECT-USEFUL-COMMANDS - Template
+
+This file describes the commands that are actually useful for working on the project. It must help an AI choose the right verification without guessing.
+
+It must stay up to date. A wrong command is more costly than a missing command.
+
+## Maintenance Rule
+
+The AI must propose an update to this file when a task:
+
+- adds, removes, or renames a development script;
+- changes the package manager;
+- changes the build, test, lint, or formatting command;
+- introduces a required setup step;
+- reveals that a documented command no longer works.
+
+Before adding a command, verify that it really exists in `package.json`, a Makefile, a script, or the project documentation.
+
+## Package Manager
+
+State the expected package manager and the related rule.
+
+```text
+npm | pnpm | yarn | bun | other
+```
+
+If the project mandates a package manager, create or update a rule in `AI/rules/`.
+
+## Installation
+
+| Command | When to use it | Notes |
+|---|---|---|
+| `npm install` | After clone or dependency changes | Adapt to the real package manager. |
+
+## Local Development
+
+| Command | Effect | Notes |
+|---|---|---|
+| `npm run dev` | Starts the local server | Specify port and prerequisites. |
+
+## Quality
+
+| Command | Effect | When to run it |
+|---|---|---|
+| `npm run build` | Compiles or bundles the project | After typed code, build config, or copied asset changes. |
+| `npm test` | Runs tests | After behavior changes. |
+| `npm run lint` | Runs lint | If the project has linting. |
+| `npm run format` | Formats code | If the project has formatting. |
+
+## Focused Tests
+
+Document commands that verify a limited scope without running the whole suite.
+
+| Command | Scope |
+|---|---|
+| `npm test -- <pattern>` | Adapt to the real runner. |
+
+## Initial Setup
+
+List required steps after a clone or initialization.
+
+```bash
+# Example to replace
+cp .env.example .env
+npm install
+```
+
+## Dangerous Or Costly Commands
+
+List commands that change the environment, delete data, deploy, or cost money.
+
+| Command | Risk | Rule |
+|---|---|---|
+| `npm run deploy` | Real deployment | Ask for explicit validation before running. |
+
+## Notes For AI
+
+- Run the smallest useful verification before finishing.
+- If a command fails, report the exact command, the symptom, and the most likely hypothesis.
+- Do not invent scripts: if a command is missing, say so and propose adding it.

package/dist/starter-doc/AI/default/AGENTS.md

@@ -0,0 +1,31 @@
+# AGENTS.md - Living Documentation
+
+This file is the entry point for Codex and agent-style tools.
+
+Before making changes:
+
+1. Read `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
+2. Read `DOCS_FOLDER/AI/PROJECT-STACK.md` to understand the stack, useful source areas, core concepts, and structural conventions.
+3. Read `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` to know the development, build, test, lint, and setup commands.
+4. Read `memory/MEMORY.md` and load only useful memory files.
+5. Read rules in `DOCS_FOLDER/AI/rules/*.md`.
+6. Read `DOCS_FOLDER/WORKLOG/current-task.md` if present to resume the state of the current task.
+7. Inspect ADRs in `DOCS_FOLDER/ADRS/` by reading `description` and `tags` first, then open the full ADR only when relevant.
+8. Check whether the `living-ai-documentation` MCP is available and use it to create, update, and keep documentation reliable when the task touches a decision, rule, command, stack, or technical document.
+
+## Living Documentation MCP
+
+The Living Documentation server exposes its MCP on `/mcp` with Streamable HTTP transport, for example `http://localhost:4321/mcp` when the server uses the default port.
+
+When the MCP is available:
+
+- use document tools to read, create, or update documentation;
+- use source tools to inspect code only when documentation is not enough;
+- attach source files with `add_metadata` after creating or updating an ADR or technical document;
+- call `refresh_metadata` once the document is aligned with the code.
+
+`PROJECT-STACK.md` and `PROJECT-USEFUL-COMMANDS.md` are living documents. If the agent discovers that they are wrong, incomplete, or obsolete, it should propose or perform their update in the same task unless the user says otherwise.
+
+If the MCP is not available, state that explicitly in the final response and do not claim that Living Documentation metadata or hashes were updated.
+
+If a rule or project instruction conflicts with the user request, state the conflict explicitly before proceeding.

package/dist/starter-doc/AI/default/CLAUDE.md

@@ -0,0 +1,31 @@
+# CLAUDE.md - Living Documentation
+
+This file is the entry point for Claude.
+
+Before making changes:
+
+1. Read `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
+2. Read `DOCS_FOLDER/AI/PROJECT-STACK.md` to understand the stack, useful source areas, core concepts, and structural conventions.
+3. Read `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` to know the development, build, test, lint, and setup commands.
+4. Read `memory/MEMORY.md` and load only useful memory files.
+5. Read rules in `DOCS_FOLDER/AI/rules/*.md`.
+6. Read `DOCS_FOLDER/WORKLOG/current-task.md` if present to resume the state of the current task.
+7. Inspect ADRs in `DOCS_FOLDER/ADRS/` by reading `description` and `tags` first, then open the full ADR only when relevant.
+8. Check whether the `living-ai-documentation` MCP is available and use it to create, update, and keep documentation reliable when the task touches a decision, rule, command, stack, or technical document.
+
+## Living Documentation MCP
+
+The Living Documentation server exposes its MCP on `/mcp` with Streamable HTTP transport, for example `http://localhost:4321/mcp` when the server uses the default port.
+
+When the MCP is available:
+
+- use document tools to read, create, or update documentation;
+- use source tools to inspect code only when documentation is not enough;
+- attach source files with `add_metadata` after creating or updating an ADR or technical document;
+- call `refresh_metadata` once the document is aligned with the code.
+
+`PROJECT-STACK.md` and `PROJECT-USEFUL-COMMANDS.md` are living documents. If the agent discovers that they are wrong, incomplete, or obsolete, it should propose or perform their update in the same task unless the user says otherwise.
+
+If the MCP is not available, state that explicitly in the final response and do not claim that Living Documentation metadata or hashes were updated.
+
+If a rule or project instruction conflicts with the user request, state the conflict explicitly before proceeding.

package/dist/starter-doc/AI/default/MEMORY.md

@@ -0,0 +1,24 @@
+# Memory Index
+
+Always store project memory in the current project's `memory/` folder.
+
+Do not write project memory to a tool-specific global folder, for example `~/.claude`.
+
+## Recommended Memory Files
+
+List the memory files that are actually useful to this project, for example:
+
+```text
+memory/project-overview.md
+memory/architecture.md
+memory/testing.md
+memory/domain-language.md
+```
+
+## Usage Rule
+
+Memory is for stable, frequently reused context.
+
+Durable decisions should be written as ADRs under `DOCS_FOLDER/ADRS/`.
+
+Update this file when memory files are added, renamed, or removed.

package/dist/starter-doc/AI/rules/no-magic-numbers.md

@@ -0,0 +1,18 @@
+---
+id: no-magic-numbers
+title: Avoid magic numbers
+severity: warning
+description: Numeric values with domain meaning must be named constants instead of repeated raw literals.
+tags: ["code-quality", "maintainability"]
+appliesTo: ["src/**/*.ts", "src/frontend/**/*.js"]
+---
+
+Numeric values with domain meaning should be named where they are introduced.
+
+Prefer a constant whose name explains the intent:
+
+```ts
+const DEFAULT_CUSTOM_SHAPE_SIZE = 65;
+```
+
+Avoid repeating raw values in code when the value carries product, rendering, sizing, timing, or protocol meaning.

package/dist/starter-doc/AI/rules/track-current-work.md

@@ -0,0 +1,23 @@
+---
+id: track-current-work
+title: Track the current task in WORKLOG
+severity: required
+description: AI assistants must read and maintain the current-task worklog to enable reliable handoff between agents.
+tags: ["worklog", "handoff", "ai-agents", "progress", "documentation"]
+appliesTo: ["**/*"]
+---
+
+Before resuming or modifying the project, read `DOCS_FOLDER/WORKLOG/current-task.md` if the file exists.
+
+When a task is started, interrupted, finished, or left with known follow-ups, update `DOCS_FOLDER/WORKLOG/current-task.md` with:
+
+- the current status;
+- the task in progress;
+- the files or areas concerned;
+- the verifications performed;
+- the remaining verifications;
+- the next recommended action.
+
+For an MVP ticket that has actually started, create or update a dedicated document under `DOCS_FOLDER/WORKLOG/` if the tracking no longer fits clearly in `current-task.md`.
+
+The worklog does not replace ADRs: it describes operational progress and resume points, not durable decisions.

package/dist/starter-doc/WORKLOG/current-task.md

@@ -0,0 +1,57 @@
+---
+**date:** 2026-01-02
+**status:** Idle
+**description:** Shared resume point between AI assistants to track the current task, its status, the files touched, the verifications, and the next action.
+**tags:** worklog, handoff, progress, resume, ai-agents
+---
+
+# Current task
+
+This document is the shared resume point between AI assistants. Every agent must read it before continuing a task and update it before handing over.
+
+## Current status
+
+Idle
+
+## Current task
+
+No application implementation task is currently in progress.
+
+## Last action performed
+
+Added the progress-tracking convention between AI assistants:
+
+- created this current worklog;
+- created the mandatory rule `track-current-work`;
+- added the worklog read step in `AGENTS.md`, `CLAUDE.md` and `PROJECT-INSTRUCTIONS.md`.
+
+## Next recommended action
+
+Start Ticket 01: initialize the React + TypeScript + Vite + Tailwind frontend project, then update this worklog with the files created, the verifications run, and any resume points.
+
+## Files or areas concerned
+
+- `AGENTS.md`
+- `CLAUDE.md`
+- `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`
+- `DOCS_FOLDER/AI/rules/track-current-work.md`
+- `DOCS_FOLDER/WORKLOG/current-task.md`
+- `DOCS_FOLDER/PRODUCT/`
+- `DOCS_FOLDER/TECHNICAL/`
+- `DOCS_FOLDER/ROADMAP/`
+- `DOCS_FOLDER/ADRS/`
+- `DOCS_FOLDER/AI/PROJECT-STACK.md`
+- `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md`
+
+## Recent verifications
+
+- Living Documentation MCP available.
+- `WORKLOG/current-task` visible in the MCP inventory.
+- `AI/rules/track-current-work` visible in the MCP inventory.
+- ADRs created with metadata and accuracy `1`.
+- `PROJECT-STACK` with metadata and accuracy `1`.
+- No ADR below the reliability threshold.
+
+## Resume notes
+
+The repository does not contain any application code yet. Do not assume the existence of `package.json`, `src/`, npm scripts, tests, or Tailwind configuration before Ticket 01.