project-tiny-context-harness 0.7.4 → 0.7.6

package/assets/skills/long-task-workflow/references/evidence-design.md

@@ -53,11 +53,13 @@ Standard frozen Playwright verifier content is trusted. Weak-observability Outco
 
 ## Visual UI Evidence
 
+- When external design resources are Source, prove only selected exact-target/constraint conditions that the Contract explicitly adopts. Candidate comparison, a Figma link or an isolated prototype run is authoring/review material and cannot become product acceptance. Resolve each acceptance-affecting resource through a stable locator plus immutable path/version/hash and declared condition coverage before Compile.
 - Use Playwright for every declared `ui_browser` visual AC and bind each independently falsifiable AC to its own `[ac:<assertion-key>]` Test Instance. A broad screenshot or one passing page case does not silently prove separate viewport, theme, state, content-stress, layout or accessibility claims.
 - Make the test environment deterministic enough for its claim: freeze the relevant browser/project, viewport, theme/mode, locale/timezone, font loading, fixtures/data and animation/motion policy in declared verifier inputs or configuration.
 - Any reviewed screenshot baseline that affects pass/fail must exist for the accepting Compile and be included in `verification_inputs`. Generated screenshots, diffs and reports are Artifacts and review material; they are not editable acceptance authority. Creating or replacing a baseline after Authority Lock is verifier-material revision and must never be silently auto-updated to make a failure pass.
 - Confirm that each baseline is a selected `exact-target` for the named surface/viewport/theme/state or implements a named `constraint`; an inspiration reference cannot become a fidelity oracle merely because it is available. The implementation's current screenshot is never its own target.
 - Screenshot comparison proves only the named visual similarity claim. Pair it with explicit DOM/layout/accessibility assertions when the Contract separately claims no overflow, action visibility, focus behavior, target size, semantic state, reduced motion or other observable behavior.
+- Keep evidence aligned with stable surface/control/target keys. Visual similarity, interaction/navigation, validation/recovery, permission behavior, accessibility and target-runtime conformance are independently failing claims and need their own Assertions/capabilities when declared; one broad screenshot or UI pass cannot prove all Control fields.
 - Run checks against production components or real product routes. A detached kit/mock harness is acceptable only when the Contract explicitly makes that artifact the product surface; otherwise it cannot substitute for the production carrier.
 - Keep subjective visual quality and approval external. A new visual direction or baseline that needs human judgment remains an explicit external confirmation even when all machine checks pass.
 - `ui_browser` proves browser UI only. When a native/mobile/desktop UI can fail independently, browser output is proxy evidence; require a project-owned live target-runtime Check that truthfully fits an existing proof surface or keep the device/simulator review external.

package/assets/skills/source-plan-authoring/SKILL.md

@@ -26,10 +26,12 @@ Record every product, technical and acceptance meaning that later work must not
 ## Relationship To Other Skills
 
 - Keep `source-plan-authoring` focused on high-fidelity Source expression and traceability.
+- For material UI, preserve stable surface/control/target keys and enough independent Control meaning for later UI Authority Closure. Do not assume a coarse product flow, `DESIGN.md` configuration or inspiration reference already supplies missing visibility, availability, validation, recovery, permission or accessibility semantics.
 - This Skill authors Source, not a Contract Draft.
 - It does not replace Contract Draft authoring inside `long-task-workflow`.
 - Its recommended structure is optional input guidance.
 - Use `context_product_plan` separately when a Tiny Context project needs product decisions classified and written as durable facts in `project_context/**`. This Skill does not replace or invoke that responsibility.
+- `design-resource-authoring` may consume the same raw inputs independently or consume an existing Source Plan to commission low/high-fidelity targets, visual candidates, a conditional Figma handoff or an isolated interaction prototype. Neither Skill invokes the other. When explicitly requested after design selection, this Skill may instead consume both a separately revised initial proposal and selected immutable design resources as ordinary inputs; it still does not generate or select those resources.
 - Use `long-task-workflow` later to read ordinary Source or a Source Plan with real Context/repository evidence, author one Delivery Contract, bind owners/paths/runners/proof, implement and run the Live Final Gate.
 
 ## Intake Modes And Source Coverage
@@ -477,6 +479,7 @@ Do not create:
 - a Source Plan CLI, Preflight or Compile step;
 - a Source Plan Receipt, Coverage Cache, Authority or state file;
 - a Delivery Contract, runner, verification input or Assertion observation;
+- a low/high-fidelity artifact, visual candidate, Figma handoff or design prototype;
 - a Context update, implementation, verification run or completion judgment.
 
 The Source Plan improves the quality of declared Source. It cannot prove that the user has expressed every real requirement.

package/dist/lib/design-md.d.ts

@@ -1,5 +1,12 @@
 export declare const DESIGN_MD_PATH = "DESIGN.md";
 export declare const UNCONFIGURED_DESIGN_AUTHORITY_MARKER = "Design authority status: `unconfigured`";
 export type DesignAuthorityStatus = "missing" | "unconfigured" | "configured";
+export interface DesignAuthorityInspection {
+    status: DesignAuthorityStatus;
+    has_authority_index: boolean;
+    token_source_selected: boolean;
+    classified_reference_count: number;
+}
 export declare function createDesignMdIfMissing(projectRoot: string): Promise<boolean>;
 export declare function inspectDesignAuthorityStatus(projectRoot: string): Promise<DesignAuthorityStatus>;
+export declare function inspectDesignAuthority(projectRoot: string): Promise<DesignAuthorityInspection>;

package/dist/lib/design-md.js

@@ -10,16 +10,57 @@ export async function createDesignMdIfMissing(projectRoot) {
     return writeTextIfChanged(target, designMdTemplate());
 }
 export async function inspectDesignAuthorityStatus(projectRoot) {
+    return (await inspectDesignAuthority(projectRoot)).status;
+}
+export async function inspectDesignAuthority(projectRoot) {
     const target = path.join(projectRoot, DESIGN_MD_PATH);
-    if (!(await pathExists(target)))
-        return "missing";
-    const content = await readText(target);
-    if (content.includes(UNCONFIGURED_DESIGN_AUTHORITY_MARKER)) {
-        return "unconfigured";
+    if (!(await pathExists(target))) {
+        return {
+            status: "missing",
+            has_authority_index: false,
+            token_source_selected: false,
+            classified_reference_count: 0,
+        };
     }
+    const content = await readText(target);
     const legacyStarter = content.includes('name: "Starter Design System"') &&
         content.includes('description: "Neutral baseline design guidance for projects that have not defined their own visual system."');
-    return legacyStarter ? "unconfigured" : "configured";
+    const status = content.includes(UNCONFIGURED_DESIGN_AUTHORITY_MARKER) || legacyStarter
+        ? "unconfigured"
+        : "configured";
+    const index = designAuthorityIndex(content);
+    return {
+        status,
+        has_authority_index: index !== null,
+        token_source_selected: index ? tokenSourceSelected(index) : false,
+        classified_reference_count: index ? classifiedReferenceCount(index) : 0,
+    };
+}
+function designAuthorityIndex(content) {
+    const match = /^###\s+Design Authority Index\s*$/imu.exec(content);
+    if (!match)
+        return null;
+    const remainder = content.slice(match.index + match[0].length);
+    const nextSection = /^#{1,3}\s+/mu.exec(remainder);
+    return nextSection ? remainder.slice(0, nextSection.index) : remainder;
+}
+function tokenSourceSelected(index) {
+    const line = index
+        .split(/\r?\n/u)
+        .find((candidate) => /authored(?: exact-value)? token source\s*:/iu.test(candidate));
+    if (!line)
+        return false;
+    const value = line.slice(line.indexOf(":") + 1).trim();
+    return (value.length > 0 &&
+        !/(?:not selected|unselected|none|n\/a|tbd|todo|unknown)/iu.test(value));
+}
+function classifiedReferenceCount(index) {
+    return index.split(/\r?\n/u).filter((line) => {
+        if (/(?:none|not) selected/iu.test(line))
+            return false;
+        const matches = line.match(/\b(?:exact-target|constraint|inspiration)\b/giu);
+        return matches?.length === 1;
+    }).length;
 }
 function designMdTemplate() {
     return [

package/dist/lib/doctor.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import { readdir } from "node:fs/promises";
 import { DEFAULT_CONTEXT_FILE_SOFT_BUDGET_BYTES, DEFAULT_CONTEXT_TOTAL_SOFT_BUDGET_BYTES, inspectDefaultContextFootprint, } from "./context-default-footprint.js";
 import { readConfig } from "./config.js";
-import { inspectDesignAuthorityStatus } from "./design-md.js";
+import { inspectDesignAuthority } from "./design-md.js";
 import { harnessConfigPath, harnessRoot } from "./harness-root.js";
 import { pathExists } from "./fs.js";
 import { unsupportedSchemaMessage } from "./schema-guard.js";
@@ -63,13 +63,28 @@ export async function runDoctor(projectRoot) {
     catch (error) {
         report.warnings.push(`default Context footprint unavailable: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const designAuthority = await inspectDesignAuthorityStatus(projectRoot);
-    if (designAuthority === "unconfigured") {
+    const designAuthority = await inspectDesignAuthority(projectRoot);
+    if (designAuthority.status === "unconfigured") {
         report.info.push("design authority: unconfigured; DESIGN.md is a starter scaffold and does not authorize material production UI until project-specific tokens and exact-target/constraint/inspiration references are selected");
     }
     else {
-        report.info.push(`design authority: ${designAuthority}`);
+        report.info.push(`design authority: ${designAuthority.status}${designAuthority.status === "configured" ? "; project-level visual-system configuration only" : ""}`);
     }
+    if (designAuthority.status === "configured") {
+        report.info.push(`design authority signals: index=${designAuthority.has_authority_index ? "present" : "missing"}, token_source=${designAuthority.token_source_selected ? "selected" : "missing-or-unselected"}, classified_references=${designAuthority.classified_reference_count}`);
+        if (!designAuthority.has_authority_index) {
+            report.warnings.push("configured DESIGN.md has no Design Authority Index; add the authored token source/generation direction and classified exact-target/constraint/inspiration references when material UI depends on them");
+        }
+        else {
+            if (!designAuthority.token_source_selected) {
+                report.warnings.push("Design Authority Index has no selected authored token source; generated tokens or current CSS must not become competing visual authority");
+            }
+            if (designAuthority.classified_reference_count === 0) {
+                report.warnings.push("Design Authority Index has no classified durable design references; inspiration, constraints and exact targets remain undeclared for material surfaces");
+            }
+        }
+    }
+    report.info.push("surface implementation readiness: not inferred; inspect owning Product Surface/Screen/Control Context, selected target or constraints, authored token source and project-owned verification for each material surface");
     for (const location of await findUserSuperpowersSkills()) {
         report.warnings.push(`user-level using-superpowers Skill detected at ${location}. Tiny Context workflows do not depend on it and doctor will not modify global configuration. To disable it explicitly for Codex, remove/disable that plugin or add a matching [[skills.config]] entry with enabled = false in ${path.join(os.homedir(), ".codex", "config.toml")}.`);
     }

package/dist/lib/long-task-authority-material-diff.js

@@ -66,14 +66,28 @@ function productClaimSemantics(contract) {
             });
         for (const control of outcome.product.controls)
             for (const [field, value] of [
+                ["surface", control.surface],
+                ["region", control.region],
                 ["location", control.location],
+                ["control_type", control.control_type],
+                ["label_content", control.label_content],
+                ["user_task", control.user_task],
+                ["visibility", control.visibility],
+                ["availability", control.availability],
                 ["trigger", control.trigger],
                 ["input", control.input],
+                ["validation", control.validation],
+                ["default_value", control.default_value],
+                ["interaction", control.interaction],
+                ["navigation_result", control.navigation_result],
                 ["loading", control.loading_state],
                 ["empty", control.empty_state],
                 ["success", control.success_state],
                 ["failure", control.failure_state],
+                ["recovery", control.recovery],
+                ["permission", control.permission],
                 ["feedback", control.feedback],
+                ["accessibility", control.accessibility],
             ])
                 if (value.trim())
                     result.set(`${outcome.key}.control.${control.key}.${field}`, value);
@@ -130,14 +144,28 @@ function flattenProductSemantics(projection) {
         }
         for (const control of outcome.controls)
             for (const field of [
+                "surface",
+                "region",
                 "location",
+                "control_type",
+                "label_content",
+                "user_task",
+                "visibility",
+                "availability",
                 "trigger",
                 "input",
+                "validation",
+                "default_value",
+                "interaction",
+                "navigation_result",
                 "loading_state",
                 "empty_state",
                 "success_state",
                 "failure_state",
+                "recovery",
+                "permission",
                 "feedback",
+                "accessibility",
             ])
                 fields.set(`${prefix}.controls.${control.key}.${field}`, control[field]);
         for (const item of outcome.non_completing_outcomes)

package/dist/lib/long-task-authority-materials.js

@@ -54,14 +54,28 @@ export function projectProductSemantics(contract) {
             })),
             controls: [...outcome.product.controls].sort(keyOrder).map((control) => ({
                 key: control.key,
+                surface: control.surface,
+                region: control.region,
                 location: control.location,
+                control_type: control.control_type,
+                label_content: control.label_content,
+                user_task: control.user_task,
+                visibility: control.visibility,
+                availability: control.availability,
                 trigger: control.trigger,
                 input: control.input,
+                validation: control.validation,
+                default_value: control.default_value,
+                interaction: control.interaction,
+                navigation_result: control.navigation_result,
                 loading_state: control.loading_state,
                 empty_state: control.empty_state,
                 success_state: control.success_state,
                 failure_state: control.failure_state,
+                recovery: control.recovery,
+                permission: control.permission,
                 feedback: control.feedback,
+                accessibility: control.accessibility,
             })),
             non_completing_outcomes: keyedStatements(outcome.product.non_completing_outcomes),
         })),

package/dist/lib/long-task-authority-policy.d.ts

@@ -79,14 +79,28 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly control: {
         key: "identity";
+        surface: "semantic_user_review";
+        region: "semantic_user_review";
         location: "semantic_user_review";
+        control_type: "semantic_user_review";
+        label_content: "semantic_user_review";
+        user_task: "semantic_user_review";
+        visibility: "semantic_user_review";
+        availability: "semantic_user_review";
         trigger: "semantic_user_review";
         input: "semantic_user_review";
+        validation: "semantic_user_review";
+        default_value: "semantic_user_review";
+        interaction: "semantic_user_review";
+        navigation_result: "semantic_user_review";
         loading_state: "semantic_user_review";
         empty_state: "semantic_user_review";
         success_state: "semantic_user_review";
         failure_state: "semantic_user_review";
+        recovery: "semantic_user_review";
+        permission: "semantic_user_review";
         feedback: "semantic_user_review";
+        accessibility: "semantic_user_review";
     };
     readonly outcome_technical: {
         obligations: "semantic_user_review";

package/dist/lib/long-task-authority-policy.js

@@ -62,14 +62,28 @@ const OWNER_AUTHORITY_POLICY = {
 };
 const CONTROL_AUTHORITY_POLICY = {
     key: "identity",
+    surface: "semantic_user_review",
+    region: "semantic_user_review",
     location: "semantic_user_review",
+    control_type: "semantic_user_review",
+    label_content: "semantic_user_review",
+    user_task: "semantic_user_review",
+    visibility: "semantic_user_review",
+    availability: "semantic_user_review",
     trigger: "semantic_user_review",
     input: "semantic_user_review",
+    validation: "semantic_user_review",
+    default_value: "semantic_user_review",
+    interaction: "semantic_user_review",
+    navigation_result: "semantic_user_review",
     loading_state: "semantic_user_review",
     empty_state: "semantic_user_review",
     success_state: "semantic_user_review",
     failure_state: "semantic_user_review",
+    recovery: "semantic_user_review",
+    permission: "semantic_user_review",
     feedback: "semantic_user_review",
+    accessibility: "semantic_user_review",
 };
 const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
     obligations: "semantic_user_review",

package/dist/lib/long-task-authority-types.d.ts

@@ -36,14 +36,28 @@ export interface ProductSemanticProjectionV2 {
         }>;
         controls: Array<{
             key: string;
+            surface: string;
+            region: string;
             location: string;
+            control_type: string;
+            label_content: string;
+            user_task: string;
+            visibility: string;
+            availability: string;
             trigger: string;
             input: string;
+            validation: string;
+            default_value: string;
+            interaction: string;
+            navigation_result: string;
             loading_state: string;
             empty_state: string;
             success_state: string;
             failure_state: string;
+            recovery: string;
+            permission: string;
             feedback: string;
+            accessibility: string;
         }>;
         non_completing_outcomes: Array<{
             key: string;

package/dist/lib/long-task-claim-definitions.js

@@ -5,14 +5,28 @@ export function generateClaims(outcome) {
         claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces));
     for (const control of outcome.product.controls) {
         const fields = [
+            ["surface", control.surface],
+            ["region", control.region],
             ["location", control.location],
+            ["control_type", control.control_type],
+            ["label_content", control.label_content],
+            ["user_task", control.user_task],
+            ["visibility", control.visibility],
+            ["availability", control.availability],
             ["trigger", control.trigger],
             ["input", control.input],
+            ["validation", control.validation],
+            ["default_value", control.default_value],
+            ["interaction", control.interaction],
+            ["navigation_result", control.navigation_result],
             ["loading", control.loading_state],
             ["empty", control.empty_state],
             ["success", control.success_state],
             ["failure", control.failure_state],
+            ["recovery", control.recovery],
+            ["permission", control.permission],
             ["feedback", control.feedback],
+            ["accessibility", control.accessibility],
         ];
         for (const [field, value] of fields)
             if (value.trim())

package/dist/lib/long-task-contract-types.d.ts

@@ -102,14 +102,28 @@ export interface DeliveryCheckV2 {
 }
 export interface DeliveryControlV2 {
     key: string;
+    surface: string;
+    region: string;
     location: string;
+    control_type: string;
+    label_content: string;
+    user_task: string;
+    visibility: string;
+    availability: string;
     trigger: string;
     input: string;
+    validation: string;
+    default_value: string;
+    interaction: string;
+    navigation_result: string;
     loading_state: string;
     empty_state: string;
     success_state: string;
     failure_state: string;
+    recovery: string;
+    permission: string;
     feedback: string;
+    accessibility: string;
 }
 interface DeliveryRequirementV2 extends KeyedStatementV2 {
     required_proof_surfaces: ProofSurface[];

package/dist/lib/long-task-product-shape.js

@@ -24,24 +24,52 @@ export function parseControls(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
         const row = object(item, itemLabel, ["key", "location"], [
+            "surface",
+            "region",
+            "control_type",
+            "label_content",
+            "user_task",
+            "visibility",
+            "availability",
             "trigger",
             "input",
+            "validation",
+            "default_value",
+            "interaction",
+            "navigation_result",
             "loading_state",
             "empty_state",
             "success_state",
             "failure_state",
+            "recovery",
+            "permission",
             "feedback",
+            "accessibility",
         ]);
         return {
             key: key(row.key, `${itemLabel}.key`),
+            surface: optionalText(row, "surface", itemLabel),
+            region: optionalText(row, "region", itemLabel),
             location: string(row.location, `${itemLabel}.location`),
+            control_type: optionalText(row, "control_type", itemLabel),
+            label_content: optionalText(row, "label_content", itemLabel),
+            user_task: optionalText(row, "user_task", itemLabel),
+            visibility: optionalText(row, "visibility", itemLabel),
+            availability: optionalText(row, "availability", itemLabel),
             trigger: optionalText(row, "trigger", itemLabel),
             input: optionalText(row, "input", itemLabel),
+            validation: optionalText(row, "validation", itemLabel),
+            default_value: optionalText(row, "default_value", itemLabel),
+            interaction: optionalText(row, "interaction", itemLabel),
+            navigation_result: optionalText(row, "navigation_result", itemLabel),
             loading_state: optionalText(row, "loading_state", itemLabel),
             empty_state: optionalText(row, "empty_state", itemLabel),
             success_state: optionalText(row, "success_state", itemLabel),
             failure_state: optionalText(row, "failure_state", itemLabel),
+            recovery: optionalText(row, "recovery", itemLabel),
+            permission: optionalText(row, "permission", itemLabel),
             feedback: optionalText(row, "feedback", itemLabel),
+            accessibility: optionalText(row, "accessibility", itemLabel),
         };
     });
 }

package/dist/lib/long-task-source-target-index.js

@@ -59,14 +59,28 @@ function target(ref, kind, text, outcomeKey, scope) {
 }
 function controlFields(control) {
     return [
+        ["surface", control.surface],
+        ["region", control.region],
         ["location", control.location],
+        ["control_type", control.control_type],
+        ["label_content", control.label_content],
+        ["user_task", control.user_task],
+        ["visibility", control.visibility],
+        ["availability", control.availability],
         ["trigger", control.trigger],
         ["input", control.input],
+        ["validation", control.validation],
+        ["default_value", control.default_value],
+        ["interaction", control.interaction],
+        ["navigation_result", control.navigation_result],
         ["loading", control.loading_state],
         ["empty", control.empty_state],
         ["success", control.success_state],
         ["failure", control.failure_state],
+        ["recovery", control.recovery],
+        ["permission", control.permission],
         ["feedback", control.feedback],
+        ["accessibility", control.accessibility],
     ];
 }
 export function sourceKindForTarget(target) {

package/dist/lib/profiles.js

@@ -55,6 +55,7 @@ export function enabledManagedSkillNames(config) {
         "context_product_plan",
         "context_surface_contract",
         "context_uiux_design",
+        "design-resource-authoring",
     ]);
     if (isProfileEnabled(config, "workflow-default"))
         names.add("normal-long-task");

package/dist/schemas/long-task-delivery-v2/long-task-delivery-v2.schema.json

@@ -196,7 +196,7 @@
             "type": "object",
             "additionalProperties": false,
             "required": ["key", "location"],
-            "properties": { "key": { "$ref": "#/$defs/key" }, "location": { "$ref": "#/$defs/nonEmpty" }, "trigger": { "type": "string", "default": "" }, "input": { "type": "string", "default": "" }, "loading_state": { "type": "string", "default": "" }, "empty_state": { "type": "string", "default": "" }, "success_state": { "type": "string", "default": "" }, "failure_state": { "type": "string", "default": "" }, "feedback": { "type": "string", "default": "" } }
+            "properties": { "key": { "$ref": "#/$defs/key" }, "surface": { "type": "string", "default": "" }, "region": { "type": "string", "default": "" }, "location": { "$ref": "#/$defs/nonEmpty" }, "control_type": { "type": "string", "default": "" }, "label_content": { "type": "string", "default": "" }, "user_task": { "type": "string", "default": "" }, "visibility": { "type": "string", "default": "" }, "availability": { "type": "string", "default": "" }, "trigger": { "type": "string", "default": "" }, "input": { "type": "string", "default": "" }, "validation": { "type": "string", "default": "" }, "default_value": { "type": "string", "default": "" }, "interaction": { "type": "string", "default": "" }, "navigation_result": { "type": "string", "default": "" }, "loading_state": { "type": "string", "default": "" }, "empty_state": { "type": "string", "default": "" }, "success_state": { "type": "string", "default": "" }, "failure_state": { "type": "string", "default": "" }, "recovery": { "type": "string", "default": "" }, "permission": { "type": "string", "default": "" }, "feedback": { "type": "string", "default": "" }, "accessibility": { "type": "string", "default": "" } }
         },
         "technical": {
             "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",