@coordiation/agent 0.1.0 → 1.0.0-rc.1

package/README.md

@@ -12,3 +12,203 @@ const pricingContext = createContextPack("pricing", manifest);
 The compact manifest reports the active framework, Coordiation packages, utility families, frequent literal classes, project rules, and trackable warnings without sending the entire source tree to an agent.
 
 Available context packs: `page`, `navigation`, `form`, `dashboard`, `pricing`, `component`, and `theme`.
+
+## Product lifecycle contracts
+
+The same package can turn a bounded product request into versioned, traceable artifacts:
+
+```js
+import {
+  approveLifecycleArtifact,
+  checkLifecycleGate,
+  initializeLifecycleProject,
+  runRequirementInterview,
+} from "@coordiation/agent";
+
+await initializeLifecycleProject({
+  cwd: process.cwd(),
+  name: "Customer Portal",
+  ownerName: "Product owner",
+});
+
+const turn = await runRequirementInterview({
+  cwd: process.cwd(),
+  intent: "login",
+  answers: { audience: "customers" },
+});
+```
+
+Each interview turn returns at most three questions. Every question includes its reason, bounded examples, a recommended answer, and permission to use a custom answer. Passing `recommended` records an explicit user-confirmed recommendation rather than silently inventing a decision.
+
+Completing an interview generates canonical JSON plus human-readable Markdown for a numbered Specification, PRD, and six acceptance criteria. Gate checks and named human approvals move the lifecycle forward without letting an agent approve its own work.
+
+Built-in capability templates cover login, dashboard, landing page, checkout, profile, settings, search, upload, and notifications. Unknown intents automatically use an answerable generic feature template instead of being rejected:
+
+```js
+import { listCapabilityTemplates, runRequirementInterview } from "@coordiation/agent";
+
+console.log(listCapabilityTemplates());
+
+const firstTurn = await runRequirementInterview({
+  cwd: process.cwd(),
+  intent: "inventory approval workflow",
+});
+```
+
+Multiple capability contracts can coexist in one project. Artifact identifiers are allocated safely (`SPEC-001`, `SPEC-002`, and so on), and gate checks can target one artifact explicitly.
+
+An approved PRD can be derived into a complete UX contract:
+
+```js
+import { createUxContract } from "@coordiation/agent";
+
+const result = await createUxContract({
+  cwd: process.cwd(),
+  prdId: "PRD-001",
+});
+```
+
+The generated `UX-001` links back to the PRD and its acceptance criteria. It contains the primary user flow, screen states, information architecture, interaction rules, responsive behavior from 320px, accessibility behavior, content rules, and a downstream evidence plan. Repeating the operation safely reuses the existing UX artifact.
+
+After UX approval, derive an implementation-oriented prototype contract:
+
+```js
+import { createPrototypeContract } from "@coordiation/agent";
+
+const result = await createPrototypeContract({
+  cwd: process.cwd(),
+  uxId: "UX-001",
+});
+```
+
+`PROTO-001` selects owned `@coordiation/ui` components, requires `@coordiation/icons`, publishes literal `co-*` layout candidates, maps every UX state to a deterministic preview fixture, and defines viewport, motion, mock-adapter, keyboard, accessibility, screenshot, and acceptance-evidence contracts.
+
+An approved prototype can become a framework-native development contract:
+
+```js
+import { createDevelopmentContract, recordDevelopmentEvidence } from "@coordiation/agent";
+
+const result = await createDevelopmentContract({ cwd: process.cwd(), prototypeId: "PROTO-001" });
+
+await recordDevelopmentEvidence({
+  cwd: process.cwd(),
+  developmentId: "DEV-001",
+  type: "source",
+  path: "src/features/login-experience/login-experience.tsx",
+});
+```
+
+Coordiation detects Next.js/React, Svelte, Astro, Laravel, WordPress, or standards-first HTML and produces native source ownership, file, state, adapter, work-item, utility, and acceptance-test plans. `GATE-DEVELOPMENT` remains blocked until source, test, build, and accessibility evidence reference real project files or reports with SHA-256 hashes.
+
+After development approval, derive an executable QA report and attach evidence produced by real project checks:
+
+```js
+import { createQaReport, recordQaEvidence } from "@coordiation/agent";
+
+await createQaReport({ cwd: process.cwd(), developmentId: "DEV-001" });
+await recordQaEvidence({
+  cwd: process.cwd(),
+  qaId: "QA-001",
+  type: "functional",
+  path: "reports/qa-functional.log",
+  command: "npm run test:e2e",
+  exitCode: 0,
+});
+```
+
+`QA-001` maps every acceptance criterion and implemented state to a test case, covers 320px, 768px, and 1280px, and defines accessibility, security, and regression checks. `GATE-QA` requires the latest functional, visual, accessibility, security, and regression evidence to be verified and passing. Failed evidence remains a release blocker until a newer passing record is attached.
+
+An approved QA report can become an immutable release candidate contract:
+
+```js
+import { createReleaseRecord, recordReleaseEvidence } from "@coordiation/agent";
+
+await createReleaseRecord({ cwd: process.cwd(), qaId: "QA-001", version: "1.0.0" });
+await recordReleaseEvidence({
+  cwd: process.cwd(),
+  releaseId: "RELEASE-001",
+  type: "candidate",
+  path: "reports/release-candidate.log",
+  command: "npm run build",
+  exitCode: 0,
+});
+```
+
+The release snapshot binds its semantic version to the approved QA revision, Development revision, acceptance criteria, and verified QA evidence with SHA-256. It contains requirement-linked changelog entries, compatibility and migration behavior, secret-safe environment names, progressive rollout batches, health checks, and an executable rollback contract. `GATE-RELEASE` requires candidate, release-notes, and rollback-validation evidence before human approval can advance to Production.
+
+An approved release can become a provider-agnostic Production record:
+
+```js
+import { createProductionRecord, recordProductionEvidence } from "@coordiation/agent";
+
+await createProductionRecord({
+  cwd: process.cwd(),
+  releaseId: "RELEASE-001",
+  environment: "production",
+  sourceRevision: "abc123def456",
+});
+
+await recordProductionEvidence({
+  cwd: process.cwd(),
+  productionId: "DEPLOY-001",
+  type: "health",
+  path: "reports/production-health.json",
+  command: "npm run healthcheck",
+  exitCode: 0,
+});
+```
+
+Deriving `DEPLOY-001` never deploys automatically. It binds an approved release to one environment and immutable source revision, copies the rollout and health contracts, defines monitoring and alert ownership, and preserves a validated rollback path. Evidence updates operational state: deployed or failed, healthy or unhealthy, active or degraded monitoring, and ready or not-ready rollback. `GATE-PRODUCTION` requires all four latest evidence records to pass before final human approval.
+
+## Revision and compatibility safety
+
+Evidence is revision-scoped. Revising an approved artifact archives its previous JSON, increments the stable artifact revision, clears active approvals and evidence, marks every dependent artifact as superseded, and resets lifecycle gates from that stage onward:
+
+```js
+import { assertSchemaCompatibility, reviseLifecycleArtifact } from "@coordiation/agent";
+
+assertSchemaCompatibility("1.0");
+await reviseLifecycleArtifact({
+  cwd: process.cwd(),
+  artifactId: "DEV-001",
+  reason: "The approved adapter contract changed.",
+  bodyPatch: { openDecisions: [] },
+});
+```
+
+Patches may only change existing body fields. Old evidence remains in the audit ledger with its original `artifactRevision`, but gates only accept evidence for the current revision. Unknown schema versions are rejected until an explicit migration exists.
+
+## Lifecycle adapters and context budget
+
+Adapters are explicit, in-process hooks. Registering an adapter never grants authority by itself and never triggers network access:
+
+```js
+import { dispatchLifecycleAdapterHook, registerLifecycleAdapter } from "@coordiation/agent";
+
+registerLifecycleAdapter(
+  { id: "audit-export", version: "1.0.0", capabilities: ["audit"], hooks: ["artifact.approved"] },
+  { "artifact.approved": async (payload) => ({ received: payload.artifactId }) },
+);
+
+await dispatchLifecycleAdapterHook("artifact.approved", { artifactId: "RELEASE-001", revision: 1 });
+```
+
+Supported hooks are `artifact.created`, `artifact.revised`, `evidence.recorded`, `gate.checked`, and `artifact.approved`. Every task context pack reports its measured byte count, estimated token count, and whether it stays within the default 1,200-token target.
+
+Published schemas:
+
+- `product-project.schema.json`
+- `lifecycle.schema.json`
+- `artifact.schema.json`
+- `traceability.schema.json`
+- `approvals.schema.json`
+- `interview.schema.json`
+- `capability-template.schema.json`
+- `ux-contract.schema.json`
+- `prototype-contract.schema.json`
+- `development-contract.schema.json`
+- `qa-report.schema.json`
+- `release-record.schema.json`
+- `production-record.schema.json`
+- `lifecycle-adapter.schema.json`
+- `evidence.schema.json`

package/approvals.schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/approvals.schema.json",
+  "title": "Coordiation approvals ledger",
+  "type": "object",
+  "required": ["schemaVersion", "kind", "approvals", "updatedAt"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "kind": { "const": "coordiation-approvals" },
+    "approvals": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "artifactId", "revision", "gate", "decision", "approver", "comment", "createdAt"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^APPROVAL-[0-9]{3}$" },
+          "artifactId": { "type": "string" },
+          "revision": { "type": "integer", "minimum": 1 },
+          "gate": { "type": "string", "pattern": "^GATE-[A-Z-]+$" },
+          "decision": { "const": "approved" },
+          "approver": {
+            "type": "object",
+            "required": ["name", "email", "role"],
+            "properties": {
+              "name": { "type": "string", "minLength": 1 },
+              "email": { "type": ["string", "null"] },
+              "role": { "const": "human-approver" }
+            },
+            "additionalProperties": false
+          },
+          "comment": { "type": "string" },
+          "createdAt": { "type": "string", "format": "date-time" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "updatedAt": { "type": "string", "format": "date-time" }
+  },
+  "additionalProperties": false
+}

package/artifact.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/artifact.schema.json",
+  "title": "Coordiation lifecycle artifact",
+  "type": "object",
+  "required": ["schemaVersion", "id", "kind", "title", "stage", "status", "revision", "owners", "derivedFrom", "acceptanceCriteria", "dependencies", "risks", "evidence", "approvals", "body", "createdAt", "updatedAt"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "id": { "type": "string", "pattern": "^[A-Z]+-[0-9]{3}$" },
+    "kind": { "enum": ["product-specification", "product-requirement-document", "acceptance-criterion", "ux-contract", "prototype-contract", "development-contract", "qa-report", "release-record", "production-record"] },
+    "title": { "type": "string", "minLength": 1 },
+    "stage": { "enum": ["specification", "prd", "ux", "prototype", "development", "qa", "release", "production"] },
+    "status": { "enum": ["draft", "approved", "superseded"] },
+    "revision": { "type": "integer", "minimum": 1 },
+    "owners": { "type": "array", "minItems": 1, "items": { "type": "string" } },
+    "derivedFrom": { "$ref": "#/$defs/ids" },
+    "acceptanceCriteria": { "$ref": "#/$defs/ids" },
+    "dependencies": { "type": "array" },
+    "risks": { "type": "array" },
+    "evidence": { "type": "array" },
+    "approvals": { "$ref": "#/$defs/ids" },
+    "body": { "type": "object" },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "updatedAt": { "type": "string", "format": "date-time" }
+  },
+  "$defs": { "ids": { "type": "array", "items": { "type": "string" }, "uniqueItems": true } },
+  "additionalProperties": false
+}

package/capability-template.schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/capability-template.schema.json",
+  "title": "Coordiation capability interview template",
+  "type": "object",
+  "required": ["id", "intent", "capability", "artifactStrategy", "questions", "maxQuestionsPerTurn"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+    "intent": { "type": "string", "minLength": 1 },
+    "capability": { "type": "string", "minLength": 1 },
+    "aliases": { "type": "array", "items": { "type": "string" }, "uniqueItems": true },
+    "artifactStrategy": { "enum": ["login", "generic-feature"] },
+    "maxQuestionsPerTurn": { "type": "integer", "minimum": 1, "maximum": 3 },
+    "questions": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "priority", "question", "why", "choices", "recommendedValue", "example"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+          "priority": { "enum": ["blocking", "recommended", "optional"] },
+          "question": { "type": "string", "minLength": 1 },
+          "why": { "type": "string", "minLength": 1 },
+          "recommendedValue": { "type": "string", "minLength": 1 },
+          "example": { "type": "string", "minLength": 1 },
+          "choices": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 4,
+            "items": {
+              "type": "object",
+              "required": ["value", "label", "effect"],
+              "properties": {
+                "value": { "type": "string", "minLength": 1 },
+                "label": { "type": "string", "minLength": 1 },
+                "effect": { "type": "string", "minLength": 1 },
+                "recommended": { "type": "boolean" }
+              },
+              "additionalProperties": false
+            }
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/development-contract.schema.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/development-contract.schema.json",
+  "title": "Coordiation development contract",
+  "type": "object",
+  "required": ["schemaVersion", "id", "kind", "stage", "status", "derivedFrom", "acceptanceCriteria", "evidence", "body"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "id": { "type": "string", "pattern": "^DEV-[0-9]{3}$" },
+    "kind": { "const": "development-contract" },
+    "stage": { "const": "development" },
+    "status": { "enum": ["draft", "approved", "superseded"] },
+    "derivedFrom": { "type": "array", "minItems": 1, "items": { "type": "string", "pattern": "^PROTO-[0-9]{3}$" } },
+    "acceptanceCriteria": { "type": "array", "minItems": 4, "items": { "type": "string", "pattern": "^AC-[0-9]{3}$" }, "uniqueItems": true },
+    "evidence": { "type": "array", "items": { "type": "string", "pattern": "^EVIDENCE-[0-9]{3}$" }, "uniqueItems": true },
+    "body": {
+      "type": "object",
+      "required": ["capability", "target", "sourcePlan", "dependencies", "utilityCandidates", "stateImplementation", "interactionImplementation", "workItems", "dataBoundary", "testPlan", "qualityCommands", "definitionOfDone", "requiredEvidence", "openDecisions"],
+      "properties": {
+        "capability": { "type": "string", "minLength": 1 },
+        "target": {
+          "type": "object",
+          "required": ["framework", "language", "extension", "sourceRoot", "nativeComponentModel"],
+          "properties": {
+            "framework": { "enum": ["Next.js", "React", "Svelte", "Astro", "Laravel/PHP", "WordPress", "HTML"] },
+            "language": { "type": "string" },
+            "extension": { "type": "string" },
+            "sourceRoot": { "type": "string" },
+            "nativeComponentModel": { "type": "string" }
+          },
+          "additionalProperties": false
+        },
+        "sourcePlan": { "type": "object", "required": ["root", "files", "ownership"] },
+        "dependencies": {
+          "type": "object",
+          "required": ["components", "icons", "css", "external"],
+          "properties": {
+            "components": { "type": "array", "minItems": 5, "items": { "type": "string" } },
+            "icons": { "const": "@coordiation/icons only" },
+            "css": { "const": "@coordiation/css" },
+            "external": { "type": "string" }
+          }
+        },
+        "utilityCandidates": { "type": "array", "minItems": 6, "items": { "type": "string", "pattern": "(^|:)co-" }, "uniqueItems": true },
+        "stateImplementation": { "type": "array", "minItems": 5 },
+        "interactionImplementation": { "type": "array", "minItems": 4 },
+        "workItems": { "type": "array", "minItems": 5 },
+        "dataBoundary": { "type": "object", "required": ["adapter", "rule", "secrets", "failures"] },
+        "testPlan": {
+          "type": "array",
+          "minItems": 4,
+          "items": {
+            "type": "object",
+            "required": ["id", "criterionId", "levels", "requiredEvidence"],
+            "properties": {
+              "id": { "type": "string" },
+              "criterionId": { "type": "string", "pattern": "^AC-[0-9]{3}$" },
+              "levels": { "type": "array", "minItems": 1, "items": { "type": "string" } },
+              "requiredEvidence": { "type": "string" }
+            },
+            "additionalProperties": false
+          }
+        },
+        "qualityCommands": { "type": "object", "required": ["test", "build", "accessibility", "note"] },
+        "definitionOfDone": { "type": "array", "minItems": 5, "items": { "type": "string" } },
+        "requiredEvidence": { "type": "array", "const": ["source", "test", "build", "accessibility"] },
+        "openDecisions": { "type": "array" }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/evidence.schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/evidence.schema.json",
+  "title": "Coordiation evidence ledger",
+  "type": "object",
+  "required": ["schemaVersion", "kind", "records", "updatedAt"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "kind": { "const": "coordiation-evidence" },
+    "records": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "artifactId", "artifactRevision", "type", "status", "path", "sha256", "command", "exitCode", "verified", "summary", "recordedBy", "createdAt"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^EVIDENCE-[0-9]{3}$" },
+          "artifactId": { "type": "string", "pattern": "^(DEV|QA|RELEASE|DEPLOY)-[0-9]{3}$" },
+          "artifactRevision": { "type": "integer", "minimum": 1 },
+          "type": { "enum": ["source", "test", "build", "functional", "visual", "accessibility", "security", "regression", "candidate", "release-notes", "rollback-validation", "deployment", "health", "monitoring", "rollback-readiness"] },
+          "status": { "enum": ["passed", "failed"] },
+          "path": { "type": "string", "minLength": 1 },
+          "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+          "command": { "type": ["string", "null"] },
+          "exitCode": { "type": ["integer", "null"] },
+          "verified": { "type": "boolean" },
+          "summary": { "type": "string" },
+          "recordedBy": { "type": "string" },
+          "createdAt": { "type": "string", "format": "date-time" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "updatedAt": { "type": "string", "format": "date-time" }
+  },
+  "additionalProperties": false
+}

package/interview.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/interview.schema.json",
+  "title": "Coordiation requirement interview",
+  "type": "object",
+  "required": ["schemaVersion", "kind", "id", "intent", "status", "maxQuestionsPerTurn", "answers", "generatedArtifacts", "createdAt", "updatedAt"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "kind": { "const": "coordiation-requirement-interview" },
+    "id": { "type": "string" },
+    "intent": { "type": "string" },
+    "status": { "enum": ["active", "completed"] },
+    "maxQuestionsPerTurn": { "type": "integer", "minimum": 1, "maximum": 3 },
+    "answers": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": ["value", "source", "answeredAt"],
+        "properties": {
+          "value": { "type": "string", "minLength": 1 },
+          "source": { "enum": ["user", "user-confirmed-recommendation"] },
+          "answeredAt": { "type": "string", "format": "date-time" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "generatedArtifacts": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "json", "markdown"],
+        "properties": {
+          "id": { "type": "string" },
+          "json": { "type": "string" },
+          "markdown": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "updatedAt": { "type": "string", "format": "date-time" },
+    "completedAt": { "type": "string", "format": "date-time" }
+  },
+  "additionalProperties": false
+}

package/lifecycle-adapter.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/lifecycle-adapter.schema.json",
+  "title": "Coordiation lifecycle adapter manifest",
+  "type": "object",
+  "required": ["id", "version", "capabilities", "hooks"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$" },
+    "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:-[0-9A-Za-z.-]+)?$" },
+    "capabilities": { "type": "array", "items": { "type": "string", "minLength": 1 }, "uniqueItems": true },
+    "hooks": {
+      "type": "array",
+      "items": { "enum": ["artifact.created", "artifact.revised", "evidence.recorded", "gate.checked", "artifact.approved"] },
+      "uniqueItems": true
+    }
+  },
+  "additionalProperties": false
+}

package/lifecycle.schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/lifecycle.schema.json",
+  "title": "Coordiation product lifecycle",
+  "type": "object",
+  "required": ["schemaVersion", "kind", "currentStage", "stages", "gates", "updatedAt"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "kind": { "const": "coordiation-lifecycle" },
+    "currentStage": { "$ref": "#/$defs/stage" },
+    "stages": {
+      "type": "array",
+      "minItems": 8,
+      "items": {
+        "type": "object",
+        "required": ["id", "order", "status", "gate"],
+        "properties": {
+          "id": { "$ref": "#/$defs/stage" },
+          "order": { "type": "integer", "minimum": 1 },
+          "status": { "enum": ["pending", "active", "approved"] },
+          "gate": { "type": "string", "pattern": "^GATE-[A-Z-]+$" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "gates": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "stage", "status", "approvalId"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^GATE-[A-Z-]+$" },
+          "stage": { "$ref": "#/$defs/stage" },
+          "status": { "enum": ["pending", "approved"] },
+          "approvalId": { "type": ["string", "null"] }
+        },
+        "additionalProperties": false
+      }
+    },
+    "updatedAt": { "type": "string", "format": "date-time" }
+  },
+  "$defs": {
+    "stage": { "enum": ["specification", "prd", "ux", "prototype", "development", "qa", "release", "production"] }
+  },
+  "additionalProperties": false
+}

package/package.json

@@ -1,18 +1,50 @@
 {
   "name": "@coordiation/agent",
-  "version": "0.1.0",
-  "description": "Compact project manifests and task context packs for AI agents using Coordiation",
+  "version": "1.0.0-rc.1",
+  "description": "AI-readable project context, product lifecycle contracts, interviews, gates, approvals, and traceability for Coordiation",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./src/index.js",
     "./context-packs.json": "./context-packs.json",
-    "./agent-manifest.schema.json": "./agent-manifest.schema.json"
+    "./schema-registry.json": "./schema-registry.json",
+    "./agent-manifest.schema.json": "./agent-manifest.schema.json",
+    "./product-project.schema.json": "./product-project.schema.json",
+    "./lifecycle.schema.json": "./lifecycle.schema.json",
+    "./artifact.schema.json": "./artifact.schema.json",
+    "./traceability.schema.json": "./traceability.schema.json",
+    "./approvals.schema.json": "./approvals.schema.json",
+    "./interview.schema.json": "./interview.schema.json",
+    "./capability-template.schema.json": "./capability-template.schema.json",
+    "./ux-contract.schema.json": "./ux-contract.schema.json",
+    "./prototype-contract.schema.json": "./prototype-contract.schema.json",
+    "./development-contract.schema.json": "./development-contract.schema.json",
+    "./qa-report.schema.json": "./qa-report.schema.json",
+    "./release-record.schema.json": "./release-record.schema.json",
+    "./production-record.schema.json": "./production-record.schema.json",
+    "./lifecycle-adapter.schema.json": "./lifecycle-adapter.schema.json",
+    "./evidence.schema.json": "./evidence.schema.json"
   },
   "files": [
     "src",
     "context-packs.json",
+    "schema-registry.json",
     "agent-manifest.schema.json",
+    "product-project.schema.json",
+    "lifecycle.schema.json",
+    "artifact.schema.json",
+    "traceability.schema.json",
+    "approvals.schema.json",
+    "interview.schema.json",
+    "capability-template.schema.json",
+    "ux-contract.schema.json",
+    "prototype-contract.schema.json",
+    "development-contract.schema.json",
+    "qa-report.schema.json",
+    "release-record.schema.json",
+    "production-record.schema.json",
+    "lifecycle-adapter.schema.json",
+    "evidence.schema.json",
     "README.md",
     "LICENSE"
   ],

package/product-project.schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://coordiation.com/schemas/product-project.schema.json",
+  "title": "Coordiation product project",
+  "type": "object",
+  "required": ["schemaVersion", "kind", "id", "name", "artifactFormat", "owners", "createdAt", "updatedAt"],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "kind": { "const": "coordiation-product-project" },
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+    "name": { "type": "string", "minLength": 1 },
+    "artifactFormat": { "const": "canonical-json-with-generated-markdown" },
+    "owners": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["name", "role"],
+        "properties": {
+          "name": { "type": "string", "minLength": 1 },
+          "email": { "type": ["string", "null"], "format": "email" },
+          "role": { "type": "string", "minLength": 1 }
+        },
+        "additionalProperties": false
+      }
+    },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "updatedAt": { "type": "string", "format": "date-time" }
+  },
+  "additionalProperties": false
+}