pactium 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,150 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.2.1] - 2026-06-20
+
+This patch release expands the published documentation set and tightens release gates. It does not change the protocol format or public API behavior.
+
+### Added
+
+- Published API, FAQ, migration, examples, changelog, and logo documentation in the npm package.
+- Package-content gate coverage for the expanded documentation set and runnable examples.
+- Published-document link verification so npm package docs cannot point to unpublished relative files.
+
+### Changed
+
+- Updated README documentation indexes to keep process documents on GitHub while package-facing docs stay self-contained.
+- Synchronized package metadata, version constants, and TypeScript declarations for the patch release.
+
+## [0.2.0] - 2026-06-19
+
+This is the first public release of Pactium as a proof-first protocol substrate. The package surface is built around verifiable operation facts, append-only recovery history, and cryptographic state verification.
+
+### Added
+
+#### Core Protocol
+
+- Canonical Value encoding (restricted IPLD/DAG-CBOR-style data model) for deterministic serialization
+- Protocol Hash with domain separation (`sha256` with fixed domain prefixes per object class)
+- Content-addressed Identifiers (`cid:sha256:<hex>` format)
+- Storage Port abstraction with local JSON backend and content-addressed block store
+
+#### Operation Ledger
+
+- RFC 6962-style Ledger Transparency Log with append-only guarantees
+- Ledger inclusion proofs (verify a leaf exists at a given tree size)
+- Ledger consistency proofs (verify a smaller ledger is a prefix of a larger one)
+- Ledger Head as verifiable ledger state summary
+- Single Ledger Append Lane for global ordering
+- Signed Ledger Head support (Ed25519) with verifier manifests
+- Last Trusted Head advancement with consistency verification
+
+#### Operation Lifecycle
+
+- Operation Intent and Operation Outcome as append-only facts
+- Terminal Outcome semantics (one outcome per intent)
+- Canceled Outcome for explicit cancellation recording
+- Open Intent recovery through verifiable Open Intent Index
+- Intent Idempotency Index and Outcome Idempotency Index
+- Idempotency Replay detection (returns existing proof without new append)
+- Causality References for linking retries, repairs, and compensations
+- Operation Causality Index for verifiable relationship queries
+
+#### Verifiable Index Engine
+
+- Canonical Prolly Tree with Content-Defined Chunking (protocol constants)
+- Membership proofs and non-membership proofs
+- Efficient structural-sharing diffs between index roots
+- Index Domain Adapters for domain-independent proof engine
+- Shared engine reused by state, workspace, lifecycle, idempotency, and causality indexes
+
+#### Workspace Projection
+
+- Workspace Order Index (workspace-local order to ledger event references)
+- Workspace Membership Index (ledger event ID to workspace membership material)
+- Synchronous projection updates during protocol commits
+- Verifiable workspace-scoped ordering and pagination
+- Default-enabled for LicoLite Aspect
+
+#### Merkle State
+
+- State Commits bound to Operation Outcomes (not Intents)
+- Content-addressed state roots through shared Verifiable Index Engine
+- Key membership and non-membership proofs
+- Efficient state diffs via Prolly Tree shared-node traversal
+
+#### Checkpoint Tree
+
+- Intent Checkpoints for lifecycle start and recoverable progress
+- Outcome Checkpoints for results, effect evidence, and state transitions
+- Verifiable node membership through shared Index Engine
+- Checkpoint Tree Head for recovery structure summary
+
+#### Proof System
+
+- Pactium Proof Envelope: cross-proof receipt binding ledger, index, state, and checkpoint evidence
+- Proof Material Refs: content-addressed references to stored proof material
+- Proof Bundles: portable CAR-like exports for offline verification
+- Proof Extensions: hash-bound host extensions (critical and non-critical)
+- Default Proof Verifier Registry for extensible verification
+- Standalone `verifyProofEnvelope()` and `verifyProofBundle()` functions
+
+#### LicoLite Aspect (`pactium/licolite`)
+
+- `createLicoLiteAspect()` with default Workspace Projection and signing
+- `createLicoLiteSigner()` for Ed25519 signing authority
+- LicoLite Policy Extension (critical, hash-bound)
+- LicoLite Workspace Effect Extension (critical, hash-bound)
+- LicoLite Verifier with structured Verification Failures
+- Evidence policy modes: `production` (fail-closed) and `opportunistic`
+- LicoLite-level Proof Bundle verification
+
+#### Maintenance and Repair
+
+- Structured Verification Failures with layer, code, severity, and evidence
+- Repair Planner: deterministic repair task generation from verification failures
+- Maintenance Task Engine with `doctor` health check
+- Repair proposals without automatic execution (host decides)
+
+#### CLI and HTTP
+
+- `pactium doctor` -- data directory health check
+- `pactium serve` -- local HTTP verification server
+- `pactium operation record` -- record operations from JSON
+- `pactium envelope verify` -- verify proof envelopes
+- `pactium bundle verify` -- verify proof bundles
+- `pactium licolite record` / `pactium licolite verify` -- LicoLite operations
+- JSON input from `--body`, `--body-file`, or stdin
+
+#### Quality and Release
+
+- Coverage-enforced tests (95% lines/functions, 90% branches)
+- Deterministic proof-vector fixtures (protocol-revision-locked)
+- Public API regression snapshots
+- Seeded property tests for encoding determinism and Prolly Tree soundness
+- Public API pressure profiles (scaled for CI, full-count for release review)
+- Release-readiness enforcement script
+- Package contents verification (excludes process docs, tests, build outputs)
+- Node.js 22 and Node.js 24 release gating
+
+### Changed
+
+- Package surface is proof-first: write operations return verifiable proof envelopes
+- Root export limited to latest proof-first API only (no historical/experimental APIs)
+- Project tooling limited to current development, operation, maintenance, and release needs
+- Durable project decisions maintained as docs and ADRs (not development scratch)
+
+### Security
+
+- Content-addressed proof material integrity checks for envelopes and bundles
+- Critical extension model: unknown critical extensions fail verification
+- LicoLite Policy Extension binding prevents proof/policy mis-association
+- LicoLite Workspace Effect Extension binding prevents proof/effect mis-association
+- Ed25519 signing support for Ledger Heads and LicoLite envelopes
+- Signed head verification with verifier manifest validation
+
+[0.2.1]: https://github.com/Unka-Malloc/Pactium/releases/tag/v0.2.1
+[0.2.0]: https://github.com/Unka-Malloc/Pactium/releases/tag/v0.2.0

package/README.md

@@ -1,92 +1,415 @@
 <p align="center">
-  <strong>Pactium — the verifiable protocol substrate for LicoLite.</strong>
+  <img src="docs/logo.svg" alt="Pactium" width="120" />
 </p>
 
-Pactium is a proof-first npm package that provides LicoLite's durable protocol substrate: verifiable operation facts, workspace projections, checkpoint recovery history, Merkle state, proof envelopes, and proof bundles.
+<h1 align="center">Pactium</h1>
 
-Pactium implements the current verifiable protocol model documented in [Architecture](./docs/architecture/ARCHITECTURE.md), [Protocols](./docs/protocols/PROTOCOLS.md), and [Protocol Profile](./docs/protocols/PROFILE.md). The package root exposes only the latest proof-first API.
+<p align="center">
+  Proof-first protocol substrate for verifiable operation facts, append-only recovery history, and cryptographic state verification.
+</p>
+
+<p align="center">
+  <a href="https://github.com/Unka-Malloc/Pactium/actions/workflows/ci.yml"><img src="https://github.com/Unka-Malloc/Pactium/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="https://www.npmjs.com/package/pactium"><img src="https://img.shields.io/npm/v/pactium.svg" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/pactium"><img src="https://img.shields.io/npm/dm/pactium.svg" alt="npm downloads" /></a>
+  <a href="https://github.com/Unka-Malloc/Pactium/blob/stable/LICENSE"><img src="https://img.shields.io/npm/l/pactium.svg" alt="license" /></a>
+  <a href="https://img.shields.io/node/v/pactium"><img src="https://img.shields.io/node/v/pactium.svg" alt="node version" /></a>
+  <img src="https://img.shields.io/badge/types-included-blue.svg" alt="TypeScript types" />
+</p>
+
+<p align="center">
+  <a href="./README.zh-CN.md">中文文档</a> |
+  <a href="./docs/API.md">API Reference</a> |
+  <a href="./docs/protocols/PROTOCOLS.md">Protocol Spec</a> |
+  <a href="https://github.com/Unka-Malloc/Pactium/blob/stable/CONTRIBUTING.md">Contributing</a>
+</p>
+
+---
+
+## Table of Contents
+
+- [Why Pactium](#why-pactium)
+- [Design Philosophy](#design-philosophy)
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [API Overview](#api-overview)
+- [CLI](#cli)
+- [Architecture](#architecture)
+- [When to Use Pactium](#when-to-use-pactium)
+- [Documentation](#documentation)
+- [Requirements](#requirements)
+- [Verification](#verification)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Why Pactium
+
+Most systems record operations into mutable databases and hope the data stays consistent. When something goes wrong -- a crash mid-write, a silent corruption, a disputed operation -- there is no cryptographic proof of what happened or didn't happen.
 
-## Direction
+Pactium solves this by making **every operation a verifiable fact**:
 
-- **Operation Ledger** is the global ordering authority and uses a transparency log for inclusion and consistency proofs.
-- **Operation lifecycle** is append-only through Operation Intent and Operation Outcome facts.
-- **Workspace Projection** is first priority for the LicoLite Aspect and is enabled by default.
-- **Verifiable Index Engine** is a shared Canonical Prolly Tree based proof engine for state, checkpoint, workspace projection, lifecycle, idempotency, and causality indexes.
-- **Proof Envelopes** bind Ledger, Workspace Projection, Checkpoint, State, and LicoLite evidence into one receipt shape.
-- **Proof Bundles** export portable CAR-like proof material for offline verification.
-- **LicoLite Aspect** is a first-class package surface under `pactium/licolite`.
+- **Append-only ledger** -- operations cannot be silently rewritten or deleted
+- **Cryptographic proofs** -- every write returns a proof envelope that can be independently verified
+- **Portable verification** -- proof bundles can be verified offline without access to the original storage
+- **Workspace isolation** -- workspace-scoped projections with verifiable membership proofs
 
-## Boundaries
+Pactium is a zero-dependency, pure-ESM Node.js package that provides a cryptographically verifiable protocol substrate. It records operation facts into an append-only transparency log, maintains verifiable indexes over workspace-scoped projections, and produces portable proof envelopes and bundles that can be independently verified without access to the original storage.
+
+Pactium is designed as the protocol substrate for [LicoLite](https://github.com/Unka-Malloc) and exposes a first-class integration surface at `pactium/licolite`.
+
+## Design Philosophy
+
+| Principle | Meaning |
+| --- | --- |
+| **Proof-first** | Write operations return verifiable proof envelopes, not storage acknowledgments. The proof is the API response. |
+| **Append-only facts** | Operations are recorded as immutable Intent and Outcome facts. Corrections create new facts with causality references rather than mutating history. |
+| **Single ordering authority** | The Operation Ledger is the only global ordering authority. All other structures derive their ordering from it. |
+| **Verifiable indexes** | Every index (state, workspace, lifecycle) uses the same Canonical Prolly Tree engine with membership and non-membership proofs. |
+| **Host boundary** | Pactium owns protocol facts and proofs. Host systems own policy decisions, side effects, authorization, and durable evidence storage. |
+| **Zero dependencies** | No runtime dependencies. Ships source directly. Predictable supply chain. |
+| **Protocol, not configuration** | Hash algorithms, encoding formats, and chunking parameters are protocol constants, not host options. Changes require a new protocol version. |
+
+## Features
+
+| Capability | Description |
+| --- | --- |
+| **Operation Ledger** | RFC 6962-style transparency log with inclusion and consistency proofs |
+| **Append-Only Lifecycle** | Operation Intent / Outcome facts with idempotency replay |
+| **Verifiable Index Engine** | Canonical Prolly Tree with membership, non-membership proofs, and efficient diffs |
+| **Workspace Projection** | Verifiable workspace-scoped order and membership indexes |
+| **Merkle State** | Content-addressed state commits bound to operation outcomes |
+| **Checkpoint Tree** | Verifiable recovery and progress structure |
+| **Proof Envelopes** | Cross-proof receipts binding ledger, index, state, and checkpoint evidence |
+| **Proof Bundles** | Portable CAR-like exports for offline verification |
+| **Signed Heads** | Optional Ed25519 ledger head signing with verifier manifests |
+| **LicoLite Aspect** | First-class integration surface with default workspace projection and signing |
+| **Repair Planning** | Deterministic repair task generation from structured verification failures |
+| **Zero Dependencies** | Pure ESM, no runtime dependencies, ships source directly |
+
+## Installation
+
+```bash
+npm install pactium
+```
+
+```bash
+pnpm add pactium
+```
 
-Pactium owns protocol facts, proof algorithms, canonical encoding, storage ports, verification, repair planning, and LicoLite protocol-substrate adapters.
+```bash
+yarn add pactium
+```
 
-LicoLite owns runtime policy decisions, operation dispatching, side effects, UI ownership, and durable host evidence storage.
+### Requirements
 
-## Status
+- Node.js 22+ or Node.js 24+
+- ESM-only (`"type": "module"` in your `package.json`)
 
-The proof-first implementation is active. Pactium accepts the latest verifiable schema only; earlier experimental data formats are rejected.
+## Quick Start
 
-## Usage
+### Record an operation with full proof
 
 ```js
 import { createPactium } from "pactium";
 
 const pactium = createPactium({ dataDir: "./.pactium" });
 
+// Record an operation and receive a verifiable proof envelope
 const envelope = await pactium.recordOperation({
   operationId: "workspace.file.write",
   workspaceId: "workspace-a",
-  idempotencyKey: "intent-a",
-  outcomeIdempotencyKey: "outcome-a",
-  input: { path: "docs/a.md" },
+  idempotencyKey: "intent-001",
+  outcomeIdempotencyKey: "outcome-001",
+  input: { path: "docs/readme.md" },
   stateMutations: [
-    { key: "docs/a.md", value: { text: "hello" } }
+    { key: "docs/readme.md", value: { content: "hello world" } }
   ]
 });
 
-console.log(await pactium.verifyEnvelope(envelope));
+// Verify the envelope against local proof material
+const result = await pactium.verifyEnvelope(envelope);
+console.log(result.ok); // true
 ```
 
+### Use the LicoLite Aspect
+
 ```js
 import { createLicoLiteAspect, createLicoLiteSigner } from "pactium/licolite";
 
-const signingSecret = process.env.LICOLITE_SIGNING_SECRET;
-if (!signingSecret) throw new Error("LICOLITE_SIGNING_SECRET is required.");
-
 const licolite = createLicoLiteAspect({
   evidencePolicy: "production",
   signer: createLicoLiteSigner({
-    signerId: "host-managed-signer",
-    secret: signingSecret
+    signerId: "host-signer",
+    secret: process.env.LICOLITE_SIGNING_SECRET
   })
 });
 
 const envelope = await licolite.recordWorkspaceOperation({
-  operationId: "workspace.effect",
+  operationId: "workspace.asset.upload",
   workspaceId: "workspace-a",
-  policyEvidence: { decision: "allow" },
-  workspaceEffectEvidence: { durableRef: "host:asset:a" }
+  policyEvidence: { decision: "allow", rule: "upload-permitted" },
+  workspaceEffectEvidence: { durableRef: "host:asset:image-001" }
 });
 
-console.log(await licolite.verifyEnvelope(envelope));
+// LicoLite-level verification checks signing + critical extensions
+const result = await licolite.verifyEnvelope(envelope);
+console.log(result.ok); // true
+```
+
+### Export and verify a portable proof bundle
+
+```js
+import { createPactium, verifyProofBundle } from "pactium";
+
+const pactium = createPactium({ dataDir: "./.pactium" });
+
+// Export envelope as a portable bundle
+const bundle = await pactium.exportProofBundle(envelope);
+
+// Verify without access to local storage
+const result = await verifyProofBundle(bundle);
+console.log(result.ok); // true
+```
+
+## API Overview
+
+Pactium exposes two package entry points:
+
+| Export | Entry | Description |
+| --- | --- | --- |
+| `pactium` | `./src/index.js` | Core proof-first protocol API |
+| `pactium/licolite` | `./src/aspects/licolite/index.js` | LicoLite integration aspect |
+
+### Core API (`pactium`)
+
+```js
+import {
+  // Instance
+  createPactium,
+
+  // Protocol constants
+  PACTIUM_PROTOCOL,
+  PACTIUM_SCHEMA_VERSION,
+  PACTIUM_PROTOCOL_PROFILE,
+
+  // Canonical encoding
+  canonicalEncode,
+  canonicalDecode,
+  normalizeCanonicalValue,
+
+  // Protocol hashing
+  protocolHash,
+  protocolHashHex,
+  cidForBytes,
+  cidForCanonical,
+
+  // Storage
+  createStoragePort,
+  resolveDataDir,
+
+  // Ledger
+  createLedgerTransparencyLog,
+  createLedgerInclusionProof,
+  verifyLedgerInclusionProof,
+  createLedgerConsistencyProof,
+  verifyLedgerConsistencyProof,
+
+  // Verifiable Index Engine
+  createVerifiableIndexEngine,
+  verifyIndexProof,
+
+  // Proof verification
+  verifyProofEnvelope,
+  verifyProofBundle,
+  createDefaultProofVerifierRegistry,
+
+  // Maintenance and repair
+  createRepairPlanner,
+  createMaintenanceTaskEngine
+} from "pactium";
+```
+
+### LicoLite Aspect (`pactium/licolite`)
+
+```js
+import {
+  createLicoLiteAspect,
+  createLicoLiteSigner,
+  recordLicoLiteWorkspaceOperation,
+  verifyLicoLiteEnvelope,
+  verifyLicoLiteBundle,
+  LICOLITE_ASPECT_PROTOCOL,
+  LICOLITE_CRITICAL_EXTENSIONS
+} from "pactium/licolite";
+```
+
+### TypeScript
+
+Pactium ships hand-written TypeScript declarations. All public types are available from the package entry points:
+
+```ts
+import type {
+  PactiumCore,
+  PactiumProofEnvelope,
+  PactiumVerificationResult,
+  PactiumProofBundle,
+  PactiumLedgerHead,
+  PactiumVerificationFailure
+} from "pactium";
+
+import type {
+  LicoLiteAspect,
+  LicoLiteSigner
+} from "pactium/licolite";
+```
+
+For the complete API reference, see [docs/API.md](./docs/API.md).
+
+## CLI
+
+Pactium ships a CLI for local operation recording and verification:
+
+```bash
+# Check data directory health
+pactium doctor --data-dir ./.pactium
+
+# Start the HTTP verification server
+pactium serve --port 7288
+
+# Record an operation
+pactium operation record --body '{"operationId":"test","workspaceId":"ws"}'
+
+# Verify a proof envelope
+pactium envelope verify --body-file ./envelope.json
+
+# Verify a proof bundle
+pactium bundle verify --body-file ./bundle.json
+
+# LicoLite workspace operations
+pactium licolite record --body '{"operationId":"ws.op","workspaceId":"ws"}'
+pactium licolite verify --body-file ./licolite-envelope.json
+```
+
+The CLI reads JSON from `--body`, `--body-file`, or stdin.
+
+## Architecture
+
+```
+                    Host System (LicoLite)
+                           |
+                    pactium/licolite
+                           |
+            +--------------+---------------+
+            |       Pactium Core           |
+            |                              |
+            |  +------------------------+  |
+            |  | Canonical Value + Hash |  |
+            |  +------------------------+  |
+            |  | Storage Port (CAS)     |  |
+            |  +------------------------+  |
+            |  | Operation Ledger       |  |  <- Global ordering authority
+            |  | (Transparency Log)     |  |
+            |  +------------------------+  |
+            |  | Verifiable Index Engine|  |  <- Shared Prolly Tree
+            |  +------------------------+  |
+            |  | Workspace Projection   |  |
+            |  | Merkle State           |  |
+            |  | Checkpoint Tree        |  |
+            |  | Lifecycle Indexes      |  |
+            |  +------------------------+  |
+            |  | Proof Envelopes        |  |
+            |  | Proof Bundles          |  |
+            |  +------------------------+  |
+            |  | Repair Planner         |  |
+            |  | Maintenance Engine     |  |
+            |  +------------------------+  |
+            +------------------------------+
 ```
 
+**Key design principles:**
+
+- The Operation Ledger is the single global ordering authority
+- All indexes share one Verifiable Index Engine (Canonical Prolly Tree)
+- Write operations return verifiable proof envelopes, not storage records
+- Proof Bundles enable verification without access to original storage
+- Host systems own policy, side effects, and durable evidence storage
+
+For detailed architecture documentation, see [docs/architecture/ARCHITECTURE.md](./docs/architecture/ARCHITECTURE.md).
+
+## When to Use Pactium
+
+**Use Pactium when you need:**
+
+- Cryptographic proof that an operation was recorded and the ledger is consistent
+- Portable proof bundles that can be verified without the original system
+- Workspace-scoped operation isolation with verifiable membership
+- Append-only operation history with deterministic recovery
+- Idempotent operation recording with replay detection
+- Verifiable state roots with efficient diffs
+
+**Pactium is not for:**
+
+- General-purpose database storage (use a database)
+- Network consensus between distributed nodes (Pactium is a local protocol substrate)
+- Authorization or access control (host systems own policy)
+- File storage or blob management (Pactium stores operation metadata and proofs)
+
+## Documentation
+
+| Document | Description |
+| --- | --- |
+| [API Reference](./docs/API.md) | Complete public API documentation |
+| [Architecture](./docs/architecture/ARCHITECTURE.md) | System architecture and module structure |
+| [Protocol Specification](./docs/protocols/PROTOCOLS.md) | Protocol behavior and data flow |
+| [Protocol Profile](./docs/protocols/PROFILE.md) | Protocol parameter matrix |
+| [LicoLite Aspect](./docs/LICOLITE-ASPECT.md) | LicoLite integration surface |
+| [Terms](./docs/TERM.md) | Protocol glossary and vocabulary |
+| [FAQ](./docs/FAQ.md) | Frequently asked questions |
+| [Migration Guide](./docs/MIGRATION.md) | Version compatibility and upgrade guidance |
+| [Examples Guide](./examples/README.md) | Annotated usage examples |
+| [Quality Gates](https://github.com/Unka-Malloc/Pactium/blob/stable/docs/QUALITY-GATES.md) | Release verification requirements |
+| [ADRs](https://github.com/Unka-Malloc/Pactium/tree/stable/docs/adr) | Architecture Decision Records (55 decisions) |
+
+## Requirements
+
+| Requirement | Version |
+| --- | --- |
+| Node.js | `^22.0.0 \|\| ^24.0.0` |
+| Module system | ESM only (`"type": "module"`) |
+| Runtime dependencies | None |
+
+Pactium is a pure ESM package. It cannot be `require()`'d from CommonJS modules. If you need CJS interop, use dynamic `import()`.
+
 ## Verification
 
+Run the full release gate locally:
+
 ```bash
 npm run verify:release
 ```
 
-The default release gate runs deterministic proof vectors, regression snapshots, seeded property tests, scaled public API pressure profiles, coverage thresholds, hygiene checks, release-readiness checks, and package dry run. CI runs the same release gate on every supported Node.js LTS major.
+This runs coverage-enforced tests, protocol proof vectors, regression snapshots, seeded property tests, scaled public API pressure profiles, hygiene checks, package-content checks, package dry run, and publish dry run.
 
-## Documentation
+For full-count pressure profiles (explicit release review):
+
+```bash
+PACTIUM_FULL_PRESSURE=1 npm run verify:protocol:gates
+```
+
+## Ecosystem
+
+| Package | Description |
+| --- | --- |
+| [`pactium`](https://www.npmjs.com/package/pactium) | Core protocol substrate (this package) |
+| `pactium/licolite` | First-class LicoLite integration aspect (included) |
+
+Pactium is the protocol substrate for [LicoLite](https://github.com/Unka-Malloc). The `pactium/licolite` aspect is a first-class package export, not an external plugin.
+
+## Contributing
 
-- [Terms](./docs/TERM.md)
-- [Protocol Overview](./docs/protocols/PROTOCOLS.md)
-- [Protocol Profile](./docs/protocols/PROFILE.md)
-- [Architecture](./docs/architecture/ARCHITECTURE.md)
-- [LicoLite Aspect](./docs/LICOLITE-ASPECT.md)
+See [CONTRIBUTING.md](https://github.com/Unka-Malloc/Pactium/blob/stable/CONTRIBUTING.md) for development setup, coding standards, and submission guidelines.
 
 ## License
 
-This project is licensed under the [GNU General Public License v3.0 or later](LICENSE).
+[GPL-3.0-or-later](./LICENSE) -- Copyright (c) Unka Y.Y.