dreative 0.5.3 → 0.5.4

package/dist/cli/audit.js

@@ -77,6 +77,38 @@ function checkAssets(projectDir, plan) {
     }
     return findings;
 }
+function checkAntiSlopPlan(plan) {
+    if (plan.version !== 3)
+        return [];
+    const findings = [];
+    const signatures = new Map();
+    for (const page of plan.pages) {
+        const signature = page.sections.map((section) => section.layoutFamily.trim().toLowerCase()).join(" > ");
+        signatures.set(signature, [...(signatures.get(signature) ?? []), page.name]);
+        const cardSections = page.sections.filter((section) => /\b(card|tile)\b/i.test(section.layoutFamily));
+        if (cardSections.length > 2)
+            findings.push(finding("warning", "anti-slop", `${page.name}: repeated card-family sections need an explicit page-specific rationale`));
+        if (page.sections.some((section) => /^\s*stack(?:ed)?(?:\s+vertically)?[.!]?\s*$/i.test(section.mobile)))
+            findings.push(finding("error", "anti-slop", `${page.name}: a section uses stack-only mobile translation`));
+        if (page.register === "task-transaction") {
+            const first = page.mobileBlueprint?.contentOrder?.[0] ?? "";
+            if (/\b(promo|decorative|hero|story)\b/i.test(first))
+                findings.push(finding("error", "anti-slop", `${page.name}: promotional or decorative content precedes the primary mobile task`));
+        }
+        for (const section of page.sections) {
+            if (/\b(testimonial|review)\b/i.test(section.name) && !/\b(state|task|concept|product|brand|evidence|decision)\b/i.test([section.layoutFamily, ...section.interactions].join(" ")))
+                findings.push(finding("warning", "anti-slop", `${page.name}/${section.name}: generic social-proof section appears detached from the page concept`));
+        }
+    }
+    for (const [signature, pages] of signatures) {
+        if (signature && pages.length > 1)
+            findings.push(finding("warning", "anti-slop", `${pages.join(", ")}: unrelated routes repeat the same section-layout shell (${signature})`));
+    }
+    const compositions = plan.coherence?.pageSpecificCompositions ?? [];
+    if (compositions.length > 1 && new Set(compositions.map((item) => `${item.register}:${item.taskModel.trim().toLowerCase()}`)).size === 1)
+        findings.push(finding("warning", "anti-slop", "all pages were assigned the same register and task model; verify that composition was not copied mechanically"));
+    return findings;
+}
 const SOURCE_EXTENSIONS = new Set([".tsx", ".jsx", ".vue", ".svelte", ".html", ".css", ".scss"]);
 const SKIP_DIRS = new Set([".git", ".dreative", "node_modules", "dist", "build", ".next", ".nuxt"]);
 function collectSourceFiles(root, current = root) {
@@ -151,6 +183,46 @@ function checkVerificationProof(projectDir, verificationFile) {
     }
     return findings;
 }
+export function checkVerificationCoverage(plan, report) {
+    const findings = [];
+    if (plan.version !== 3)
+        return findings;
+    if (report.version !== 2)
+        return [finding("error", "migration", "v3 plans require verify.json version 2; legacy verification cannot satisfy depth and mobile guarantees")];
+    const passing = report.evidence.filter((item) => item.status === "pass");
+    for (const page of plan.pages) {
+        for (const viewportClass of ["desktop", "mobile", "narrow-mobile"]) {
+            if (!passing.some((item) => item.pageId === page.id && item.viewportClass === viewportClass && item.proof?.viewport))
+                findings.push(finding("error", "verification", `${page.name}: missing passing ${viewportClass} evidence with an exact viewport`));
+        }
+        if ((plan.depth === "restructure" || plan.depth === "reimagine") && !passing.some((item) => item.pageId === page.id && item.kind === "structural-depth"))
+            findings.push(finding("error", "verification", `${page.name}: missing structural-depth evidence against its structural delta`));
+        if (!passing.some((item) => item.pageId === page.id && item.kind === "preservation"))
+            findings.push(finding("error", "verification", `${page.name}: missing preservation evidence`));
+        for (const check of page.mobileBlueprint?.verificationChecks ?? []) {
+            if (!passing.some((item) => item.pageId === page.id && (item.viewportClass === "mobile" || item.viewportClass === "narrow-mobile") && item.mobileChecks?.includes(check)))
+                findings.push(finding("error", "verification", `${page.name}: missing mobile evidence for ${check}`));
+        }
+        for (const section of page.sections) {
+            for (const criterion of section.verification) {
+                if (typeof criterion === "string") {
+                    findings.push(finding("error", "verification", `${page.name}/${section.name}: v3 criteria must be typed objects, not strings`));
+                    continue;
+                }
+                for (const viewport of criterion.viewports) {
+                    const match = passing.find((item) => item.criterionId === criterion.id &&
+                        item.pageId === criterion.pageId &&
+                        item.sectionId === criterion.sectionId &&
+                        item.kind === criterion.kind &&
+                        item.viewportClass === viewport);
+                    if (!match)
+                        findings.push(finding("error", "verification", `${page.name}/${section.name}: no passing ${viewport} evidence is associated with criterion ${criterion.id}`));
+                }
+            }
+        }
+    }
+    return findings;
+}
 export function runDirectDesignAudit(projectDir) {
     const root = path.join(projectDir, ".dreative");
     const planFile = path.join(root, "plan.json");
@@ -165,13 +237,13 @@ export function runDirectDesignAudit(projectDir) {
     findings.push(...checkArtifact(ledgerFile, "ledger", validateDecisionLedger));
     findings.push(...checkArtifact(verificationFile, "verification", validateVerificationReport));
     findings.push(...checkVerificationProof(projectDir, verificationFile));
-    if (plan.doctrineVersion !== 2) {
-        findings.push(finding("warning", "migration", "legacy v2 plan accepted; add doctrineVersion: 2 and the new creative-control fields on the next design run"));
+    const verification = fs.existsSync(verificationFile) ? readJson(verificationFile) : undefined;
+    if (plan.version !== 3 || plan.doctrineVersion !== 3) {
+        findings.push(finding("warning", "migration", "legacy v2 plan accepted for compatibility only; migrate to plan v3 and verify v2 for structural-depth, mobile-blueprint, expression, and evidence-association guarantees"));
     }
     else {
         try {
             const { registry, reflexFonts } = loadRuleFiles();
-            const verification = fs.existsSync(verificationFile) ? readJson(verificationFile) : undefined;
             for (const message of validateRuleControls(plan, registry, reflexFonts, verification))
                 findings.push(finding("error", "rules", message));
         }
@@ -181,15 +253,19 @@ export function runDirectDesignAudit(projectDir) {
     }
     findings.push(...checkSkillClosure(plan));
     findings.push(...checkAssets(projectDir, plan));
+    findings.push(...checkAntiSlopPlan(plan));
     findings.push(...checkStaticQuality(projectDir, plan));
-    const verify = fs.existsSync(verificationFile) ? JSON.stringify(readJson(verificationFile)) : "";
-    for (const page of plan.pages) {
-        for (const section of page.sections) {
-            for (const criterion of section.verification) {
-                if (!verify.includes(criterion))
-                    findings.push(finding("warning", "verification", `${page.name}/${section.name}: no evidence references criterion: ${criterion}`));
-            }
-        }
+    if (verification)
+        findings.push(...checkVerificationCoverage(plan, verification));
+    if (plan.version === 2) {
+        const verifyText = verification ? JSON.stringify(verification) : "";
+        for (const page of plan.pages)
+            for (const section of page.sections)
+                for (const criterion of section.verification) {
+                    const text = typeof criterion === "string" ? criterion : criterion.claim;
+                    if (!verifyText.includes(text))
+                        findings.push(finding("warning", "verification", `${page.name}/${section.name}: no legacy evidence references criterion: ${text}`));
+                }
     }
     return { ok: !findings.some((item) => item.level === "error"), findings };
 }

package/dist/cli/audit.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { runDirectDesignAudit } from "./audit.js";
+import { checkVerificationCoverage, runDirectDesignAudit } from "./audit.js";
 test("direct-design audit verifies artifacts and preservation needles", () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "dreative-audit-"));
     try {
@@ -77,3 +77,42 @@ test("direct-design audit verifies artifacts and preservation needles", () => {
         fs.rmSync(root, { recursive: true, force: true });
     }
 });
+test("v3 audit associates criteria by id, page, section, kind, and viewport", () => {
+    const criterion = { id: "depth", claim: "Architecture matches delta", kind: "structural-depth", pageId: "outlets", sectionId: "workspace", viewports: ["desktop"] };
+    const plan = {
+        version: 3,
+        doctrineVersion: 3,
+        depth: "restructure",
+        pages: [{ id: "outlets", name: "Outlets", mobileBlueprint: { verificationChecks: ["no-horizontal-overflow"] }, sections: [{ id: "workspace", name: "Workspace", verification: [criterion] }] }],
+    };
+    const makeEvidence = (id, kind, viewportClass) => ({
+        id,
+        criterion: id,
+        criterionId: id === "depth-proof" ? "depth" : id,
+        pageId: "outlets",
+        sectionId: id === "depth-proof" ? "workspace" : undefined,
+        kind,
+        viewportClass,
+        mobileChecks: viewportClass === "desktop" ? undefined : ["no-horizontal-overflow"],
+        status: "pass",
+        evidence: "Browser and test evidence",
+        proof: { timestamp: new Date().toISOString(), viewport: { width: viewportClass === "desktop" ? 1280 : viewportClass === "mobile" ? 390 : 320, height: 844 }, artifactPath: `.dreative/${id}.png` },
+    });
+    const report = {
+        version: 2,
+        generatedAt: new Date().toISOString(),
+        evidence: [
+            makeEvidence("desktop", "responsive", "desktop"),
+            makeEvidence("mobile", "responsive", "mobile"),
+            makeEvidence("narrow", "responsive", "narrow-mobile"),
+            makeEvidence("preserved", "preservation", "desktop"),
+            makeEvidence("depth-proof", "structural-depth", "desktop"),
+        ],
+    };
+    assert.deepEqual(checkVerificationCoverage(plan, report), []);
+    plan.pages[0].mobileBlueprint.verificationChecks.push("touch-targets");
+    assert.ok(checkVerificationCoverage(plan, report).some((item) => item.message.includes("touch-targets")));
+    plan.pages[0].mobileBlueprint.verificationChecks.pop();
+    report.evidence[4].sectionId = "wrong-section";
+    assert.ok(checkVerificationCoverage(plan, report).some((item) => item.message.includes("criterion depth")));
+});

package/dist/server/index.js

@@ -6,7 +6,7 @@ import { Store, findBlock, replaceBlock, newId } from "./store.js";
 import { requestAgent, respond, nextEvent, pushFinish } from "./agentQueue.js";
 import { computeDiff } from "./diff.js";
 import { buildPreview, previewHtml, replicaHtml } from "./preview.js";
-import { buildDesignPlan } from "../shared/design.js";
+import { buildDesignPlan, buildDesignSourceContext, buildRuntimeCoherence } from "../shared/design.js";
 import { startJob, getJob } from "./jobs.js";
 const here = path.dirname(fileURLToPath(import.meta.url));
 function cloneWithNewIds(block) {
@@ -180,6 +180,7 @@ export function createServer(projectDir) {
         if (!page)
             throw new Error("page not found");
         const siblingPages = project.pages.filter((p) => p.id !== pageId).map((p) => p.name);
+        const projectComposition = buildRuntimeCoherence(project.pages, project.brief);
         const blockRefs = [];
         const collect = (b) => {
             if (b.refImage)
@@ -188,18 +189,22 @@ export function createServer(projectDir) {
         };
         collect(page.layout);
         const outFile = `generated/${pageId}.tsx`;
+        const plan = buildDesignPlan(page, project.brief);
+        const source = buildDesignSourceContext(plan.depth, page.generatedFile);
         await requestAgent("design-page", {
             pageName: page.name,
             layout: page.layout,
             brief: project.brief,
-            // Dreative decides, the agent executes: resolved dials, per-section
-            // layout families, spacing/motion budgets, doctrine lints.
-            plan: buildDesignPlan(page, project.brief),
+            // Dreative resolves depth, source strategy, contracts, budgets, and
+            // blocking lints; the agent authors the page-specific composition.
+            plan,
             refImage: page.refImage,
             blockRefs,
             designPrompt: designPrompt ?? page.designPrompt,
-            previousFile: page.generatedFile,
+            source,
+            ...(source.previousFile ? { previousFile: source.previousFile } : {}),
             siblingPages,
+            projectComposition,
             outFile,
         }, update);
         if (!fs.existsSync(path.join(store.root, outFile)))

package/dist/shared/artifacts.js

@@ -1,13 +1,73 @@
 function nonEmpty(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
+function concreteList(value, minimum = 1) {
+    return Array.isArray(value) && value.length >= minimum && value.every((item) => nonEmpty(item) && !/^(improve|modernize|make better|n\/a|none)$/i.test(item.trim()));
+}
+function validateV3Page(page, prefix, depth, tier) {
+    const errors = [];
+    const validRegisters = ["marketing-storytelling", "discovery-browse", "task-transaction", "account-status", "administration", "data-dense-utility", "authentication", "system-state"];
+    if (!page.register || !validRegisters.includes(page.register))
+        errors.push(`${prefix}.register is required`);
+    const expectedStrategy = depth === "restyle" ? "patch" : depth === "relayout" ? "recompose" : "rebuild-from-contracts";
+    if (page.sourceStrategy !== expectedStrategy)
+        errors.push(`${prefix}.sourceStrategy must be ${expectedStrategy} for ${depth}`);
+    const delta = page.structuralDelta;
+    if (!delta)
+        errors.push(`${prefix}.structuralDelta is required`);
+    else {
+        for (const key of ["existingModel", "proposedModel", "existingParadigm", "proposedParadigm", "depthHonesty"]) {
+            if (!nonEmpty(delta[key]) || /^(old|new|modern|expressive|same|n\/a)( layout| design)?$/i.test(delta[key].trim()))
+                errors.push(`${prefix}.structuralDelta.${key} must be concrete and page-specific`);
+        }
+        if (!concreteList(delta.materialChanges))
+            errors.push(`${prefix}.structuralDelta.materialChanges cannot be empty or generic`);
+        if (!Array.isArray(delta.survivingBoundaries) || !Array.isArray(delta.rebuiltBoundaries) || !concreteList(delta.preservedContracts) || !Array.isArray(delta.retainedPatterns) || !concreteList(delta.forbiddenCarryovers))
+            errors.push(`${prefix}.structuralDelta requires boundaries, preservation, retained-pattern rationale, and forbidden carryovers`);
+        if (delta.retainedPatterns?.some((item) => !nonEmpty(item.pattern) || !nonEmpty(item.rationale)))
+            errors.push(`${prefix}.structuralDelta retained patterns need rationale`);
+        const structural = [delta.proposedModel, delta.proposedParadigm, ...delta.materialChanges].join(" ");
+        if ((depth === "restructure" || depth === "reimagine") && !/\b(architect|component|boundary|workflow|navigation|interaction|model|task|rebuild|replace|merge|remove|reorder|hierarchy|workspace)\b/i.test(structural))
+            errors.push(`${prefix}: ${depth} cannot be satisfied by stylesheet, token, typography, card, or animation changes alone`);
+        if ((depth === "restructure" || depth === "reimagine") && /\b(same (sections|layout)|only (colou?r|font|style)|new (colou?r|font|shadow|radius))\b/i.test(structural))
+            errors.push(`${prefix}: structural delta contradicts selected depth ${depth}`);
+    }
+    const mobile = page.mobileBlueprint;
+    if (!mobile)
+        errors.push(`${prefix}.mobileBlueprint is required`);
+    else {
+        const fields = [mobile.primaryTask, mobile.firstViewportPurpose, mobile.safeArea, mobile.navigationModel, mobile.mobileOnlyComposition, mobile.mediaStrategy, mobile.motionStrategy, mobile.keyboardAndForms, mobile.composition390, mobile.fallback320, mobile.stackingRejection];
+        if (fields.some((field) => !nonEmpty(field)) || !concreteList(mobile.contentOrder, 2) || !concreteList(mobile.beforeFirstScroll) || !nonEmpty(mobile.primaryThumbAction?.action) || !nonEmpty(mobile.primaryThumbAction?.placement))
+            errors.push(`${prefix}.mobileBlueprint must specify task, order, first viewport, thumb action, safe areas, navigation, media, motion, forms, 390px, and 320px behavior`);
+        if (/^\s*stack(?:ed)?(?:\s+vertically)?[.!]?\s*$/i.test(mobile.mobileOnlyComposition) || /^\s*stack(?:ed)?(?:\s+vertically)?[.!]?\s*$/i.test(mobile.stackingRejection))
+            errors.push(`${prefix}.mobileBlueprint cannot be only “stack vertically”`);
+        if (!mobile.desktopTranslation || !Array.isArray(mobile.desktopTranslation.retained) || !Array.isArray(mobile.desktopTranslation.translated) || !Array.isArray(mobile.desktopTranslation.removed) || !Array.isArray(mobile.desktopTranslation.replaced))
+            errors.push(`${prefix}.mobileBlueprint must classify retained, translated, removed, and replaced desktop features`);
+        if (!Array.isArray(mobile.verificationChecks) || mobile.verificationChecks.length < 13)
+            errors.push(`${prefix}.mobileBlueprint must include the complete mobile verification checklist`);
+    }
+    if (tier === "expressive" || tier === "award") {
+        if (!page.expression && !nonEmpty(page.intentionalCalm))
+            errors.push(`${prefix} needs an expression contract or a documented intentional-calm rationale`);
+        if (page.expression) {
+            const expression = page.expression;
+            if ([expression.mechanism, expression.communicates, expression.projectFit, expression.location, expression.mobileTranslation, expression.reducedMotion, expression.fallback, expression.verification].some((field) => !nonEmpty(field)))
+                errors.push(`${prefix}.expression is incomplete`);
+            if (/\b(fade|slide|stagger|hover|scale|gradient|large typography)\b/i.test(expression.mechanism) && !/\b(content|state|progress|selection|navigation|transform|spatial|relationship)\b/i.test(expression.communicates))
+                errors.push(`${prefix}.expression is decorative-only`);
+        }
+    }
+    return errors;
+}
 export function validatePlan(value) {
     const errors = [];
     const plan = value;
     if (!plan || typeof plan !== "object")
         return ["plan must be an object"];
-    if (plan.version !== 2)
-        errors.push("plan.version must be 2 (migrate legacy top-level sections into pages[])");
+    if (plan.version !== 2 && plan.version !== 3)
+        errors.push("plan.version must be 2 (legacy) or 3");
+    if (plan.version === 3 && plan.doctrineVersion !== 3)
+        errors.push("plan.doctrineVersion must be 3 for v3 plans");
     if (!nonEmpty(plan.request))
         errors.push("plan.request is required");
     if (!nonEmpty(plan.createdAt) || Number.isNaN(Date.parse(plan.createdAt)))
@@ -34,6 +94,8 @@ export function validatePlan(value) {
         const pagePrefix = `pages[${pageIndex}]`;
         if (!nonEmpty(page.id) || !nonEmpty(page.name))
             errors.push(`${pagePrefix} requires id and name`);
+        if (plan.version === 3 && plan.depth && plan.tier)
+            errors.push(...validateV3Page(page, pagePrefix, plan.depth, plan.tier));
         if (!Array.isArray(page.skills) || !page.skills.includes("ux") || !page.skills.includes("mobile"))
             errors.push(`${pagePrefix}.skills must include ux and mobile`);
         for (const globalSkill of plan.skillPolicy?.global ?? []) {
@@ -55,6 +117,15 @@ export function validatePlan(value) {
                 errors.push(`${prefix} requires mobile and fallback treatments`);
             if (!Array.isArray(section.verification) || section.verification.length === 0)
                 errors.push(`${prefix}.verification cannot be empty`);
+            if (plan.version === 3) {
+                for (const [criterionIndex, criterion] of (section.verification ?? []).entries()) {
+                    const criterionPrefix = `${prefix}.verification[${criterionIndex}]`;
+                    if (typeof criterion === "string")
+                        errors.push(`${criterionPrefix} must be a typed verification criterion`);
+                    else if (!nonEmpty(criterion.id) || !nonEmpty(criterion.claim) || !criterion.kind || criterion.pageId !== page.id || (criterion.sectionId !== undefined && criterion.sectionId !== section.id) || !Array.isArray(criterion.viewports) || criterion.viewports.length === 0)
+                        errors.push(`${criterionPrefix} must associate id, claim, kind, page, section, and viewports`);
+                }
+            }
             if (section.status === "planned")
                 errors.push(`${prefix} is still planned`);
             if ((section.status === "fallback" || section.status === "cut") && !nonEmpty(section.reason))
@@ -86,7 +157,7 @@ export function validatePlan(value) {
             for (const asset of section.assets ?? []) {
                 if (!nonEmpty(asset.id) || !nonEmpty(asset.path) || !nonEmpty(asset.purpose))
                     errors.push(`${prefix} contains an incomplete asset`);
-                if (plan.doctrineVersion === 2 && (!asset.importance || !asset.preparation))
+                if ((plan.doctrineVersion === 2 || plan.doctrineVersion === 3) && (!asset.importance || !asset.preparation))
                     errors.push(`${prefix} asset ${asset.id || "unknown"} needs importance and a preparation decision`);
                 else if (asset.preparation) {
                     if (!asset.importance || !["supporting", "key"].includes(asset.importance))
@@ -105,6 +176,14 @@ export function validatePlan(value) {
             }
         }
     }
+    if (plan.version === 3) {
+        if (!plan.coherence || !nonEmpty(plan.coherence.globalVisualLanguage) || !nonEmpty(plan.coherence.globalInteractionLanguage) || !concreteList(plan.coherence.sharedPrimitives) || !concreteList(plan.coherence.crossPageContinuity) || !concreteList(plan.coherence.prohibitedRepeatedShells))
+            errors.push("plan.coherence must define global languages, shared primitives, continuity, and prohibited repeated shells");
+        if (!Array.isArray(plan.coherence?.pageSpecificCompositions) || plan.coherence.pageSpecificCompositions.length !== (plan.pages?.length ?? 0))
+            errors.push("plan.coherence.pageSpecificCompositions must cover every page");
+        if ((plan.tier === "expressive" || plan.tier === "award") && !(plan.pages ?? []).some((page) => page.expression))
+            errors.push(`${plan.tier} multi-page plans require at least one authored expression mechanism across the product`);
+    }
     for (const skill of plan.skills ?? []) {
         if (!coveredSkills.has(skill))
             errors.push(`selected skill ${skill} is not assigned to any page`);
@@ -162,8 +241,8 @@ export function validateVerificationReport(value) {
     if (!report || typeof report !== "object")
         return ["verification report must be an object"];
     const errors = [];
-    if (report.version !== 1)
-        errors.push("verification report version must be 1");
+    if (report.version !== 1 && report.version !== 2)
+        errors.push("verification report version must be 1 (legacy) or 2");
     if (!Array.isArray(report.evidence))
         errors.push("verification evidence must be an array");
     if (report.refinement) {
@@ -195,6 +274,22 @@ export function validateVerificationReport(value) {
             errors.push(`verification.evidence[${index}] is incomplete`);
         if (item.timelineState && !timelineStates.has(item.timelineState))
             errors.push(`verification.evidence[${index}].timelineState is invalid`);
+        if (report.version === 2) {
+            if (!item.kind || !["visual", "interaction", "responsive", "preservation", "structural-depth"].includes(item.kind))
+                errors.push(`verification.evidence[${index}].kind is required`);
+            if (!nonEmpty(item.criterionId) || !nonEmpty(item.pageId) || !item.viewportClass)
+                errors.push(`verification.evidence[${index}] must associate criterionId, pageId, and viewportClass`);
+            if (item.viewportClass !== "non-visual" && !item.proof?.viewport)
+                errors.push(`verification.evidence[${index}] visual/responsive evidence requires an exact viewport`);
+            if (item.viewportClass === "desktop" && item.proof?.viewport && item.proof.viewport.width < 1200)
+                errors.push(`verification.evidence[${index}] desktop evidence must be at least 1200px wide`);
+            if (item.viewportClass === "mobile" && item.proof?.viewport && (item.proof.viewport.width < 375 || item.proof.viewport.width > 430))
+                errors.push(`verification.evidence[${index}] mobile evidence must be approximately 390px wide`);
+            if (item.viewportClass === "narrow-mobile" && item.proof?.viewport && item.proof.viewport.width > 340)
+                errors.push(`verification.evidence[${index}] narrow-mobile evidence must be approximately 320px wide`);
+            if ((item.viewportClass === "mobile" || item.viewportClass === "narrow-mobile") && (!Array.isArray(item.mobileChecks) || item.mobileChecks.length === 0))
+                errors.push(`verification.evidence[${index}] mobile evidence must name the checks it proves`);
+        }
         const proof = item.proof;
         if (!proof || !nonEmpty(proof.timestamp) || Number.isNaN(Date.parse(proof.timestamp))) {
             errors.push(`verification.evidence[${index}].proof requires a valid timestamp`);

package/dist/shared/artifacts.test.js

@@ -0,0 +1,101 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validatePlan, validateVerificationReport } from "./artifacts.js";
+import { buildDesignPlan } from "./design.js";
+const page = {
+    id: "checkout",
+    name: "Checkout",
+    status: "skeleton",
+    canvasPos: { x: 0, y: 0 },
+    layout: {
+        id: "root", type: "column", label: "Checkout shell", children: [
+            { id: "promo", type: "hero", label: "Promotional introduction" },
+            { id: "form", type: "form", label: "Choose delivery and continue", children: [{ id: "continue", type: "button", label: "Continue", text: "Continue" }] },
+            { id: "cards", type: "card-grid", label: "Delivery option cards" },
+        ],
+    },
+};
+function v3Plan() {
+    const runtime = buildDesignPlan(page, { transformationDepth: "restructure", aesthetic: "trust", variance: 3, motion: 2 });
+    return {
+        version: 3,
+        doctrineVersion: 3,
+        request: "Restructure checkout without changing its contracts",
+        createdAt: "2026-07-14T00:00:00.000Z",
+        tier: "solid",
+        depth: "restructure",
+        skills: ["ux", "mobile"],
+        skillPolicy: { mode: "hybrid", global: ["ux", "mobile"], routingApproved: true, userAssignments: [] },
+        designRead: { register: "task transaction", concept: "continuous checkout", signature: "selection carries forward" },
+        coherence: {
+            globalVisualLanguage: "A restrained operational language with one accent and consistent state markers.",
+            globalInteractionLanguage: "Selections persist visibly and primary actions respond to readiness.",
+            sharedPrimitives: ["state marker", "task action"],
+            pageSpecificCompositions: [{ pageId: page.id, register: runtime.register, taskModel: runtime.mobileBlueprint.primaryTask, expressionLevel: "calm" }],
+            crossPageContinuity: ["Selection state carries into the next route"],
+            prohibitedRepeatedShells: ["Oversized headline plus decorative panel plus rounded card container"],
+        },
+        pages: [{
+                id: page.id,
+                name: page.name,
+                register: runtime.register,
+                sourceStrategy: runtime.sourceStrategy,
+                structuralDelta: runtime.structuralDelta,
+                mobileBlueprint: runtime.mobileBlueprint,
+                skills: ["ux", "mobile"],
+                sections: [{
+                        id: "task",
+                        name: "Checkout task",
+                        layoutFamily: "continuous decision workspace",
+                        skills: ["ux", "mobile"],
+                        interactions: ["select delivery"],
+                        mobile: "Task controls precede supporting content and keep the continuation action reachable.",
+                        fallback: "Semantic fieldset and submit action",
+                        verification: [{ id: "checkout-depth", claim: "Implemented checkout matches the approved task-first architecture", kind: "structural-depth", pageId: page.id, sectionId: "task", viewports: ["desktop", "mobile", "narrow-mobile"] }],
+                        assets: [],
+                        status: "shipped",
+                    }],
+            }],
+        preservationManifest: ".dreative/preservation.json",
+        decisionLedger: ".dreative/ledger.json",
+    };
+}
+test("v3 plan accepts independent solid ambition with restructure depth", () => {
+    assert.deepEqual(validatePlan(v3Plan()), []);
+});
+test("v3 validator rejects stylesheet-only deep transformation", () => {
+    const plan = v3Plan();
+    plan.pages[0].structuralDelta = {
+        ...plan.pages[0].structuralDelta,
+        proposedModel: "Same sections with modern expressive styling",
+        proposedParadigm: "Same layout with new colors and fonts",
+        materialChanges: ["New colors, fonts, card radii, shadows, and fade animations"],
+    };
+    assert.ok(validatePlan(plan).some((error) => error.includes("cannot be satisfied")));
+});
+test("v3 validator rejects stack-only mobile blueprint", () => {
+    const plan = v3Plan();
+    plan.pages[0].mobileBlueprint.mobileOnlyComposition = "stack vertically";
+    assert.ok(validatePlan(plan).some((error) => error.includes("stack vertically")));
+});
+test("verification v2 requires associated page, criterion, kind, and real mobile viewports", () => {
+    const report = {
+        version: 2,
+        generatedAt: "2026-07-14T00:00:00.000Z",
+        evidence: [{
+                id: "mobile-check",
+                criterion: "Mobile task is usable",
+                criterionId: "checkout-mobile",
+                pageId: "checkout",
+                kind: "responsive",
+                viewportClass: "mobile",
+                mobileChecks: ["no-horizontal-overflow"],
+                status: "pass",
+                evidence: "Browser screenshot and interaction run",
+                proof: { timestamp: "2026-07-14T00:00:00.000Z", viewport: { width: 390, height: 844 }, artifactPath: ".dreative/screenshots/checkout-mobile.png" },
+            }],
+    };
+    assert.deepEqual(validateVerificationReport(report), []);
+    report.evidence[0].proof.viewport = { width: 768, height: 844 };
+    assert.ok(validateVerificationReport(report).some((error) => error.includes("approximately 390px")));
+});