@workflow-cannon/workspace-kit 0.16.1 → 0.17.0

package/dist/core/config-metadata.js

@@ -56,6 +56,19 @@ const REGISTRY = {
         exposure: "public",
         writableLayers: ["project", "user"]
     },
+    "tasks.strictValidation": {
+        key: "tasks.strictValidation",
+        type: "boolean",
+        description: "When true, task mutations validate the full active task set before persistence and fail on invalid task records.",
+        default: false,
+        domainScope: "project",
+        owningModule: "task-engine",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "public",
+        writableLayers: ["project", "user"]
+    },
     "policy.extraSensitiveModuleCommands": {
         key: "policy.extraSensitiveModuleCommands",
         type: "array",

package/dist/core/workspace-kit-config.js

@@ -11,7 +11,8 @@ export function getProjectConfigPath(workspacePath) {
 export const KIT_CONFIG_DEFAULTS = {
     core: {},
     tasks: {
-        storeRelativePath: ".workspace-kit/tasks/state.json"
+        storeRelativePath: ".workspace-kit/tasks/state.json",
+        strictValidation: false
     },
     documentation: {},
     responseTemplates: {

package/dist/modules/task-engine/index.js

@@ -6,6 +6,9 @@ import { getNextActions } from "./suggestions.js";
 import { readWorkspaceStatusSnapshot } from "./dashboard-status.js";
 import { openPlanningStores } from "./planning-open.js";
 import { runMigrateTaskPersistence } from "./migrate-task-persistence-runtime.js";
+import { planningStrictValidationEnabled } from "./planning-config.js";
+import { validateTaskSetForStrictMode } from "./strict-task-validation.js";
+import { validateKnownTaskTypeRequirements } from "./task-type-validation.js";
 import { buildWishlistItemFromIntake, validateWishlistIntakePayload, validateWishlistUpdatePayload, WISHLIST_ID_RE } from "./wishlist-validation.js";
 export { TaskStore } from "./store.js";
 export { TransitionService } from "./service.js";
@@ -17,6 +20,7 @@ export { validateWishlistIntakePayload, validateWishlistUpdatePayload, buildWish
 export { openPlanningStores } from "./planning-open.js";
 export { getTaskPersistenceBackend, planningSqliteDatabaseRelativePath, planningTaskStoreRelativePath, planningWishlistStoreRelativePath } from "./planning-config.js";
 const TASK_ID_RE = /^T\d+$/;
+const SAFE_METADATA_PATH_RE = /^[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*$/;
 const MUTABLE_TASK_FIELDS = new Set([
     "title",
     "type",
@@ -30,6 +34,70 @@ const MUTABLE_TASK_FIELDS = new Set([
     "technicalScope",
     "acceptanceCriteria"
 ]);
+function isRecordLike(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readMetadataPath(metadata, path) {
+    if (!metadata || !SAFE_METADATA_PATH_RE.test(path)) {
+        return undefined;
+    }
+    const parts = path.split(".");
+    let current = metadata;
+    for (const part of parts) {
+        if (!isRecordLike(current)) {
+            return undefined;
+        }
+        if (!Object.prototype.hasOwnProperty.call(current, part)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function digestPayload(value) {
+    return crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function readIdempotencyValue(args) {
+    const raw = args.clientMutationId;
+    if (typeof raw !== "string") {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function findIdempotentMutation(store, mutationType, taskId, clientMutationId) {
+    const log = store.getMutationLog();
+    for (let idx = log.length - 1; idx >= 0; idx -= 1) {
+        const entry = log[idx];
+        if (entry.mutationType !== mutationType || entry.taskId !== taskId) {
+            continue;
+        }
+        if (!entry.details || entry.details.clientMutationId !== clientMutationId) {
+            continue;
+        }
+        return {
+            payloadDigest: typeof entry.details.payloadDigest === "string" ? entry.details.payloadDigest : undefined
+        };
+    }
+    return null;
+}
+function strictValidationError(store, effectiveConfig) {
+    if (!planningStrictValidationEnabled({ effectiveConfig })) {
+        return null;
+    }
+    return validateTaskSetForStrictMode(store.getAllTasks());
+}
 function nowIso() {
     return new Date().toISOString();
 }
@@ -244,6 +312,11 @@ export const taskEngineModule = {
                     name: "dashboard-summary",
                     file: "dashboard-summary.md",
                     description: "Stable JSON cockpit summary for UI clients (tasks + maintainer status snapshot)."
+                },
+                {
+                    name: "explain-task-engine-model",
+                    file: "explain-task-engine-model.md",
+                    description: "Explain model variants, planning boundaries, lifecycle transitions, and required fields."
                 }
             ]
         }
@@ -323,6 +396,7 @@ export const taskEngineModule = {
             const priority = typeof args.priority === "string" && ["P1", "P2", "P3"].includes(args.priority)
                 ? args.priority
                 : undefined;
+            const clientMutationId = readIdempotencyValue(args);
             if (!id || !title || !TASK_ID_RE.test(id) || !["proposed", "ready"].includes(status)) {
                 return {
                     ok: false,
@@ -330,9 +404,7 @@ export const taskEngineModule = {
                     message: "create-task requires id/title, id format T<number>, and status of proposed or ready"
                 };
             }
-            if (store.getTask(id)) {
-                return { ok: false, code: "duplicate-task-id", message: `Task '${id}' already exists` };
-            }
+            const evidenceType = command.name === "create-task-from-plan" ? "create-task-from-plan" : "create-task";
             const timestamp = nowIso();
             const task = {
                 id,
@@ -351,7 +423,6 @@ export const taskEngineModule = {
                 technicalScope: Array.isArray(args.technicalScope) ? args.technicalScope.filter((x) => typeof x === "string") : undefined,
                 acceptanceCriteria: Array.isArray(args.acceptanceCriteria) ? args.acceptanceCriteria.filter((x) => typeof x === "string") : undefined
             };
-            store.addTask(task);
             if (command.name === "create-task-from-plan") {
                 const planRef = typeof args.planRef === "string" && args.planRef.trim().length > 0 ? args.planRef.trim() : undefined;
                 if (!planRef) {
@@ -362,13 +433,63 @@ export const taskEngineModule = {
                     };
                 }
                 task.metadata = { ...(task.metadata ?? {}), planRef };
-                store.updateTask(task);
             }
-            const evidenceType = command.name === "create-task-from-plan" ? "create-task-from-plan" : "create-task";
+            const createPayloadForDigest = {
+                id: task.id,
+                title: task.title,
+                type: task.type,
+                status: task.status,
+                priority: task.priority,
+                dependsOn: task.dependsOn ?? [],
+                unblocks: task.unblocks ?? [],
+                phase: task.phase ?? null,
+                metadata: task.metadata ?? null,
+                ownership: task.ownership ?? null,
+                approach: task.approach ?? null,
+                technicalScope: task.technicalScope ?? [],
+                acceptanceCriteria: task.acceptanceCriteria ?? []
+            };
+            const payloadDigest = digestPayload(createPayloadForDigest);
+            if (clientMutationId) {
+                const prior = findIdempotentMutation(store, evidenceType, id, clientMutationId);
+                if (prior) {
+                    if (prior.payloadDigest !== payloadDigest) {
+                        return {
+                            ok: false,
+                            code: "idempotency-key-conflict",
+                            message: `clientMutationId '${clientMutationId}' was already used for a different ${evidenceType} payload on ${id}`
+                        };
+                    }
+                    return {
+                        ok: true,
+                        code: "task-create-idempotent-replay",
+                        message: `Idempotent create replay for task '${id}'`,
+                        data: { task: store.getTask(id), replayed: true }
+                    };
+                }
+            }
+            if (store.getTask(id)) {
+                return { ok: false, code: "duplicate-task-id", message: `Task '${id}' already exists` };
+            }
+            const knownTypeValidationError = validateKnownTaskTypeRequirements(task);
+            if (knownTypeValidationError) {
+                return {
+                    ok: false,
+                    code: knownTypeValidationError.code,
+                    message: knownTypeValidationError.message
+                };
+            }
+            store.addTask(task);
             store.addMutationEvidence(mutationEvidence(evidenceType, id, actor, {
                 initialStatus: task.status,
-                source: command.name
+                source: command.name,
+                clientMutationId,
+                payloadDigest
             }));
+            const strictIssue = strictValidationError(store, ctx.effectiveConfig);
+            if (strictIssue) {
+                return { ok: false, code: "strict-task-validation-failed", message: strictIssue };
+            }
             await store.save();
             return {
                 ok: true,
@@ -388,6 +509,7 @@ export const taskEngineModule = {
             if (!taskId || !updates) {
                 return { ok: false, code: "invalid-task-schema", message: "update-task requires taskId and updates object" };
             }
+            const clientMutationId = readIdempotencyValue(args);
             const task = store.getTask(taskId);
             if (!task) {
                 return { ok: false, code: "task-not-found", message: `Task '${taskId}' not found` };
@@ -401,8 +523,43 @@ export const taskEngineModule = {
                 };
             }
             const updatedTask = { ...task, ...updates, updatedAt: nowIso() };
+            const payloadDigest = digestPayload({ taskId, updates });
+            if (clientMutationId) {
+                const prior = findIdempotentMutation(store, "update-task", taskId, clientMutationId);
+                if (prior) {
+                    if (prior.payloadDigest !== payloadDigest) {
+                        return {
+                            ok: false,
+                            code: "idempotency-key-conflict",
+                            message: `clientMutationId '${clientMutationId}' was already used for a different update-task payload on ${taskId}`
+                        };
+                    }
+                    return {
+                        ok: true,
+                        code: "task-update-idempotent-replay",
+                        message: `Idempotent update replay for task '${taskId}'`,
+                        data: { task, replayed: true }
+                    };
+                }
+            }
+            const knownTypeValidationError = validateKnownTaskTypeRequirements(updatedTask);
+            if (knownTypeValidationError) {
+                return {
+                    ok: false,
+                    code: knownTypeValidationError.code,
+                    message: knownTypeValidationError.message
+                };
+            }
             store.updateTask(updatedTask);
-            store.addMutationEvidence(mutationEvidence("update-task", taskId, actor, { updatedFields: Object.keys(updates) }));
+            store.addMutationEvidence(mutationEvidence("update-task", taskId, actor, {
+                updatedFields: Object.keys(updates),
+                clientMutationId,
+                payloadDigest
+            }));
+            const strictIssue = strictValidationError(store, ctx.effectiveConfig);
+            if (strictIssue) {
+                return { ok: false, code: "strict-task-validation-failed", message: strictIssue };
+            }
             await store.save();
             return { ok: true, code: "task-updated", message: `Updated task '${taskId}'`, data: { task: updatedTask } };
         }
@@ -424,6 +581,10 @@ export const taskEngineModule = {
             const updatedTask = { ...task, archived: true, archivedAt, updatedAt: archivedAt };
             store.updateTask(updatedTask);
             store.addMutationEvidence(mutationEvidence("archive-task", taskId, actor));
+            const strictIssue = strictValidationError(store, ctx.effectiveConfig);
+            if (strictIssue) {
+                return { ok: false, code: "strict-task-validation-failed", message: strictIssue };
+            }
             await store.save();
             return { ok: true, code: "task-archived", message: `Archived task '${taskId}'`, data: { task: updatedTask } };
         }
@@ -500,6 +661,10 @@ export const taskEngineModule = {
             store.updateTask(updatedTask);
             const mutationType = command.name === "add-dependency" ? "add-dependency" : "remove-dependency";
             store.addMutationEvidence(mutationEvidence(mutationType, taskId, actor, { dependencyTaskId }));
+            const strictIssue = strictValidationError(store, ctx.effectiveConfig);
+            if (strictIssue) {
+                return { ok: false, code: "strict-task-validation-failed", message: strictIssue };
+            }
             await store.save();
             return {
                 ok: true,
@@ -608,6 +773,17 @@ export const taskEngineModule = {
         if (command.name === "list-tasks") {
             const statusFilter = typeof args.status === "string" ? args.status : undefined;
             const phaseFilter = typeof args.phase === "string" ? args.phase : undefined;
+            const typeFilter = typeof args.type === "string" && args.type.trim().length > 0 ? args.type.trim() : undefined;
+            const categoryFilter = typeof args.category === "string" && args.category.trim().length > 0 ? args.category.trim() : undefined;
+            const tagsFilterRaw = args.tags;
+            const tagsFilter = typeof tagsFilterRaw === "string"
+                ? [tagsFilterRaw]
+                : Array.isArray(tagsFilterRaw)
+                    ? tagsFilterRaw.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+                    : [];
+            const metadataFilters = isRecordLike(args.metadataFilters)
+                ? Object.entries(args.metadataFilters).filter(([path]) => SAFE_METADATA_PATH_RE.test(path))
+                : [];
             const includeArchived = args.includeArchived === true;
             let tasks = includeArchived ? store.getAllTasks() : store.getActiveTasks();
             if (statusFilter) {
@@ -616,6 +792,25 @@ export const taskEngineModule = {
             if (phaseFilter) {
                 tasks = tasks.filter((t) => t.phase === phaseFilter);
             }
+            if (typeFilter) {
+                tasks = tasks.filter((t) => t.type === typeFilter);
+            }
+            if (categoryFilter) {
+                tasks = tasks.filter((t) => readMetadataPath(t.metadata, "category") === categoryFilter);
+            }
+            if (tagsFilter.length > 0) {
+                tasks = tasks.filter((t) => {
+                    const tags = readMetadataPath(t.metadata, "tags");
+                    if (!Array.isArray(tags)) {
+                        return false;
+                    }
+                    const normalized = tags.filter((entry) => typeof entry === "string");
+                    return tagsFilter.every((tag) => normalized.includes(tag));
+                });
+            }
+            if (metadataFilters.length > 0) {
+                tasks = tasks.filter((t) => metadataFilters.every(([path, expected]) => readMetadataPath(t.metadata, path) === expected));
+            }
             return {
                 ok: true,
                 code: "tasks-listed",
@@ -651,6 +846,69 @@ export const taskEngineModule = {
                 data: { ...suggestion, scope: "tasks-only" }
             };
         }
+        if (command.name === "explain-task-engine-model") {
+            const allStatuses = ["proposed", "ready", "in_progress", "blocked", "completed", "cancelled"];
+            const lifecycle = allStatuses.map((status) => ({
+                status,
+                allowedActions: getAllowedTransitionsFrom(status).map((entry) => ({
+                    action: entry.action,
+                    targetStatus: entry.to
+                }))
+            }));
+            return {
+                ok: true,
+                code: "task-engine-model-explained",
+                message: "Task Engine model variants, planning boundary, and lifecycle transitions.",
+                data: {
+                    modelVersion: 1,
+                    variants: [
+                        {
+                            variant: "execution-task",
+                            idPattern: "^T[0-9]+$",
+                            appearsInExecutionPlanning: true,
+                            requiredFields: ["id", "title", "type", "status", "createdAt", "updatedAt"],
+                            optionalFields: [
+                                "priority",
+                                "dependsOn",
+                                "unblocks",
+                                "phase",
+                                "metadata",
+                                "ownership",
+                                "approach",
+                                "technicalScope",
+                                "acceptanceCriteria"
+                            ]
+                        },
+                        {
+                            variant: "wishlist-item",
+                            idPattern: "^W[0-9]+$",
+                            appearsInExecutionPlanning: false,
+                            requiredFields: [
+                                "id",
+                                "title",
+                                "problemStatement",
+                                "expectedOutcome",
+                                "impact",
+                                "constraints",
+                                "successSignals",
+                                "requestor",
+                                "evidenceRef",
+                                "status",
+                                "createdAt",
+                                "updatedAt"
+                            ],
+                            optionalFields: ["metadata", "convertedTaskIds", "closedAt", "closeReason"],
+                            notes: "Wishlist is ideation-only and excluded from task ready queues."
+                        }
+                    ],
+                    planningBoundary: {
+                        executionQueues: "tasks-only",
+                        wishlistScope: "separate-namespace"
+                    },
+                    executionTaskLifecycle: lifecycle
+                }
+            };
+        }
         if (command.name === "get-task-summary") {
             const tasks = store.getActiveTasks();
             const suggestion = getNextActions(tasks);
@@ -864,6 +1122,12 @@ export const taskEngineModule = {
                 }
                 wishlistStore.updateItem(updatedWishlist);
             };
+            if (planningStrictValidationEnabled({ effectiveConfig: ctx.effectiveConfig })) {
+                const strictIssue = validateTaskSetForStrictMode([...store.getAllTasks(), ...built]);
+                if (strictIssue) {
+                    return { ok: false, code: "strict-task-validation-failed", message: strictIssue };
+                }
+            }
             if (planning.kind === "sqlite") {
                 planning.sqliteDual.withTransaction(applyConvertMutations);
             }

package/dist/modules/task-engine/planning-config.d.ts

@@ -8,3 +8,6 @@ export declare function planningWishlistStoreRelativePath(ctx: {
     effectiveConfig?: Record<string, unknown>;
 }): string | undefined;
 export declare function planningSqliteDatabaseRelativePath(ctx: ModuleLifecycleContext): string;
+export declare function planningStrictValidationEnabled(ctx: {
+    effectiveConfig?: Record<string, unknown>;
+}): boolean;

package/dist/modules/task-engine/planning-config.js

@@ -35,3 +35,10 @@ export function planningSqliteDatabaseRelativePath(ctx) {
         ? p.trim()
         : ".workspace-kit/tasks/workspace-kit.db";
 }
+export function planningStrictValidationEnabled(ctx) {
+    const tasks = ctx.effectiveConfig?.tasks;
+    if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) {
+        return false;
+    }
+    return tasks.strictValidation === true;
+}

package/dist/modules/task-engine/strict-task-validation.d.ts

@@ -0,0 +1,3 @@
+import type { TaskEntity } from "./types.js";
+export declare function validateTaskEntityForStrictMode(task: TaskEntity): string | null;
+export declare function validateTaskSetForStrictMode(tasks: TaskEntity[]): string | null;

package/dist/modules/task-engine/strict-task-validation.js

@@ -0,0 +1,52 @@
+import { validateKnownTaskTypeRequirements } from "./task-type-validation.js";
+const TASK_ID_RE = /^T\d+$/;
+const ALLOWED_STATUS = new Set(["proposed", "ready", "in_progress", "blocked", "completed", "cancelled"]);
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isIsoDateLike(value) {
+    return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
+}
+export function validateTaskEntityForStrictMode(task) {
+    if (!TASK_ID_RE.test(task.id)) {
+        return `task '${task.id}' has invalid id format`;
+    }
+    if (typeof task.title !== "string" || task.title.trim().length === 0) {
+        return `task '${task.id}' has empty title`;
+    }
+    if (!ALLOWED_STATUS.has(task.status)) {
+        return `task '${task.id}' has unsupported status '${String(task.status)}'`;
+    }
+    if (typeof task.type !== "string" || task.type.trim().length === 0) {
+        return `task '${task.id}' has empty type`;
+    }
+    if (!isIsoDateLike(task.createdAt) || !isIsoDateLike(task.updatedAt)) {
+        return `task '${task.id}' has invalid createdAt/updatedAt timestamps`;
+    }
+    if (task.dependsOn !== undefined && !isStringArray(task.dependsOn)) {
+        return `task '${task.id}' has invalid dependsOn values`;
+    }
+    if (task.unblocks !== undefined && !isStringArray(task.unblocks)) {
+        return `task '${task.id}' has invalid unblocks values`;
+    }
+    if (task.technicalScope !== undefined && !isStringArray(task.technicalScope)) {
+        return `task '${task.id}' has invalid technicalScope values`;
+    }
+    if (task.acceptanceCriteria !== undefined && !isStringArray(task.acceptanceCriteria)) {
+        return `task '${task.id}' has invalid acceptanceCriteria values`;
+    }
+    const knownTypeValidation = validateKnownTaskTypeRequirements(task);
+    if (knownTypeValidation) {
+        return `task '${task.id}': ${knownTypeValidation.message}`;
+    }
+    return null;
+}
+export function validateTaskSetForStrictMode(tasks) {
+    for (const task of tasks) {
+        const issue = validateTaskEntityForStrictMode(task);
+        if (issue) {
+            return issue;
+        }
+    }
+    return null;
+}

package/dist/modules/task-engine/task-type-validation.d.ts

@@ -0,0 +1,10 @@
+import type { TaskEntity } from "./types.js";
+export type KnownTaskTypeValidationError = {
+    code: "invalid-task-type-requirements";
+    message: string;
+};
+/**
+ * Optional strictness for known task types.
+ * Unknown/custom task types remain passthrough for compatibility.
+ */
+export declare function validateKnownTaskTypeRequirements(task: TaskEntity): KnownTaskTypeValidationError | null;

package/dist/modules/task-engine/task-type-validation.js

@@ -0,0 +1,26 @@
+function nonEmptyStringArray(value) {
+    return Array.isArray(value) && value.some((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+/**
+ * Optional strictness for known task types.
+ * Unknown/custom task types remain passthrough for compatibility.
+ */
+export function validateKnownTaskTypeRequirements(task) {
+    if (task.type !== "improvement") {
+        return null;
+    }
+    const missing = [];
+    if (!nonEmptyStringArray(task.acceptanceCriteria)) {
+        missing.push("acceptanceCriteria");
+    }
+    if (!nonEmptyStringArray(task.technicalScope)) {
+        missing.push("technicalScope");
+    }
+    if (missing.length === 0) {
+        return null;
+    }
+    return {
+        code: "invalid-task-type-requirements",
+        message: `Type '${task.type}' requires non-empty fields: ${missing.join(", ")}`
+    };
+}

package/dist/modules/task-engine/types.d.ts

@@ -65,7 +65,7 @@ export type TaskEngineError = {
     code: TaskEngineErrorCode;
     message: string;
 };
-export type TaskEngineErrorCode = "invalid-transition" | "guard-rejected" | "dependency-unsatisfied" | "task-not-found" | "duplicate-task-id" | "invalid-task-schema" | "invalid-task-update" | "invalid-task-id-format" | "task-archived" | "dependency-cycle" | "duplicate-dependency" | "storage-read-error" | "storage-write-error" | "invalid-adapter" | "import-parse-error";
+export type TaskEngineErrorCode = "invalid-transition" | "guard-rejected" | "dependency-unsatisfied" | "task-not-found" | "duplicate-task-id" | "invalid-task-schema" | "invalid-task-type-requirements" | "invalid-task-update" | "invalid-task-id-format" | "task-archived" | "dependency-cycle" | "duplicate-dependency" | "storage-read-error" | "storage-write-error" | "invalid-adapter" | "import-parse-error";
 export type TaskAdapter = {
     name: string;
     supports: () => TaskAdapterCapability[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "check": "tsc -p tsconfig.json --noEmit",
+    "check": "tsc -p tsconfig.json --noEmit && node scripts/check-task-engine-run-contracts.mjs",
     "clean": "rm -rf dist",
     "test": "pnpm run build && node --test test/**/*.test.mjs",
     "pack:dry-run": "pnpm run build && pnpm pack --pack-destination ./artifacts/workspace-kit-pack",
@@ -48,6 +48,7 @@
   "files": [
     "dist",
     "src/modules/documentation",
+    "schemas",
     "package.json"
   ],
   "dependencies": {

package/schemas/compatibility-matrix.schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://workflow-cannon.dev/schemas/compatibility-matrix.schema.json",
+  "title": "Workflow Cannon Compatibility Matrix",
+  "type": "object",
+  "required": ["schemaVersion", "generatedAt", "runtime", "modules", "channels"],
+  "properties": {
+    "schemaVersion": {
+      "type": "integer",
+      "minimum": 1
+    },
+    "generatedAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "runtime": {
+      "type": "object",
+      "required": ["runtimeVersion", "moduleContractVersion", "configSchema", "policyTraceSchema"],
+      "properties": {
+        "runtimeVersion": { "type": "string", "minLength": 1 },
+        "moduleContractVersion": { "type": "string", "enum": ["1"] },
+        "configSchema": { "type": "integer", "minimum": 1 },
+        "policyTraceSchema": { "type": "integer", "minimum": 1 }
+      },
+      "additionalProperties": false
+    },
+    "modules": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "version", "contractVersion", "compatibilityLevel", "supportedRuntime", "severity"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "version": { "type": "string", "pattern": "^\\d+\\.\\d+\\.\\d+$" },
+          "contractVersion": { "type": "string", "enum": ["1"] },
+          "compatibilityLevel": { "type": "string", "enum": ["strict", "compatible", "warn-only"] },
+          "supportedRuntime": { "type": "string", "minLength": 1 },
+          "severity": { "type": "string", "enum": ["error", "warn"] },
+          "notes": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "channels": {
+      "type": "array",
+      "minItems": 3,
+      "items": {
+        "type": "object",
+        "required": ["name", "npmDistTag", "releaseLabel", "tagPrefix", "allowPrerelease"],
+        "properties": {
+          "name": { "type": "string", "enum": ["canary", "stable", "lts"] },
+          "npmDistTag": { "type": "string", "minLength": 1 },
+          "releaseLabel": { "type": "string", "minLength": 1 },
+          "tagPrefix": { "type": "string", "minLength": 1 },
+          "allowPrerelease": { "type": "boolean" },
+          "rollback": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}