project-tiny-context-harness 0.8.16 → 0.8.17

package/assets/skills/design-resource-authoring/references/recovery-and-writeback.md

@@ -6,6 +6,10 @@ Load this reference only for a material generation/revision loop which needs com
 
 A simple scoped preview creates zero recovery files and persisted recovery bytes, adds no user pause or Provider generation beyond the one requested commission, runs no formal handoff/preflight, performs no Proposal writeback and opens no helper write transaction. Its ordinary requested preview is the commission itself; recovery adds and reports zero tool actions. Keep its temporary reasoning in the current turn.
 
+Ordinary conversational review and selection remains legal outside this deterministic path. It creates no approval record or persistent selection state and must be reconfirmed if lost before authorized materialization. Deterministic cross-interruption selection uses only the existing raw-digest-bound marked Source, `ty-dra-authority-v1`, selected-resource binding and conditional checkpoint below; do not invent `review_set_id`, approval status or another checkpoint kind.
+
+Without the complete bindings below, an ordinary loop may report only conservative impact analysis from readable Source, identify unverified scope and regenerate conservatively within the hard ceiling or return `decision-required`. It cannot claim that only identified resources are affected. When this recoverable path has a complete current catalog, change and preservation claims remain bounded to its exact Requirements-to-Resource, Resource-to-Requirements, explicitly unchanged, blast-radius and inactive-leakage universes.
+
 Use a recovery checkpoint only when interruption would otherwise lose material accepted/rejected/unresolved semantics, immutable Provider identity or a pending CAS writeback. It is versioned, ignored, task-local, non-authoritative and deletable. It is not Source, Context, a Contract, Authority, Evidence, Receipt, Gate, Provider registry, scheduler, acceptance state or completion conclusion. There is no global session registry, event log, heartbeat, polling loop or state-machine service.
 
 For deterministic classification, apply four fail-closed invariants before details: validate every semantic key independently; retain every valid accepted/rejected/unresolved decision and its authority row even when a later patch, audit or owner fails; reject deterministic checkpoint input whose claimed Source authority is invalid; and report a requested or pending unsafe reconciliation/writeback as blocked rather than as no action. Provider/resource selection never fills a missing authority row, and one key's authority never covers another key.
@@ -80,6 +84,8 @@ Never use a prior Agent summary or generated resource as the next Base. Missing
 
 Prepare one disclosure-reviewed JSON input using schema `design-resource-recovery-input-v4`, including session identity, Base, `authority_sources`, delegations/Deltas, exact accepted/rejected/unresolved sets, current Design Authority identity, immutable Provider project/run/resource references, `selected_resource_bindings`, one frozen `audit_expectations` catalog and optional writeback. The catalog owns the exact changed, unchanged, resource-decision, blast-radius and inactive-leakage row expectations, including Delta/resource/condition/basis/binding identities. Every resource-decision binding freezes one and only one `final_disposition`: `proposal-written` with its exact operation ID, `resource-owned-exact-visual` with its selected resource/conditions/structured owner, `not-adopted` for rejected or superseded meaning, or `unresolved` for unresolved meaning. Audit observes and verifies this owner; it never selects it. Changing an owner requires checkpoint `update` with digest CAS. The catalog is the only checkpoint audit-universe/owner owner; current audit rows must be set-equal to it rather than merely non-empty. Selected resource bindings declare one unique resource key, generic `repository-snapshot` or `external-immutable` identity, locator, raw-byte digest and exact condition identities. Arbitrary condition strings and duplicate identities fail closed.
 
+The existing selected-resource, condition, Design-Authority and authority-Source fields jointly bind deterministic selection to the canonical selected-source digest, target, declared conditions and controlling Source/Design-Authority identity; no new selection field or status is added. Preview URLs, names and exports are derived outputs. A proved equivalent export does not change the selection binding, while a visible or semantic difference requires a new user review/selection and, when retained here, the existing digest-CAS checkpoint update.
+
 Create/retain a checkpoint for a real interruption or pending CAS writeback; use `none` when neither exists, and `reject` when a requested new checkpoint, input, destination or existing checkpoint cannot be admitted. Never turn an invalid authority request into `none` merely because no file was written. Then explicitly create it when required:
 
 ```text
@@ -178,7 +184,7 @@ When no binding is `proposal-written`, omit writeback and do not invent an empty
 ty-context design-resource recovery reconcile <session> --audit <audit.json>
 ```
 
-Recovery uses only generic repository snapshot/source-record identity. It does not accept a `formal-handoff-target` label or duplicate the formal handoff parser; formal Web/App handoff readiness remains owned by `ty-context design-resource preflight`.
+Recovery uses only generic repository snapshot/source-record identity. It does not accept a `formal-handoff-target` label, an implementation-feasibility-readiness label, duplicate either formal parser, or persist a selected production strategy. Formal Web/App input closure remains owned by `ty-context design-resource preflight`, while production ownership remains downstream.
 
 A valid resource-owned-only case may be `allow` plus `reconciliation-balanced` with `write_action: none`, but the helper-level `handoff_ready` projection remains false. Any later readiness claim waits for the Skill-owned composition of current Provider/resource revalidation, durable final ownership and applicable formal preflight; never infer readiness merely from a balanced read-only reconcile.
 

package/assets/skills/design-resource-authoring/references/resource-selection.md

@@ -15,6 +15,21 @@ Extract the smallest explicit output or development boundary before interpreting
 
 Rich background improves a bounded artifact. It never authorizes more artifacts. Necessary surrounding context may show where a partial feature lives, but it does not place the rest of that page or product in scope. If the user supplies a complete app plan but asks to preview one button, generate at most the one-control resource. If the user asks for design resources for one development slice, cover that slice through its material controls and conditions, not the whole background product.
 
+When an in-scope decision exposes an outside-ceiling effect, assess and explain that effect without generating or revising the outside subjects. Return the existing `decision-required` disposition with `reason: scope-expansion-required`. The user may choose an in-scope alternative or explicitly expand scope; only then recompute the ceiling and coverage. The reason is not a new status, approval or workflow state.
+
+For page, flow or complex-control generation, recover the available authoritative constraints before deriving a commission:
+
+- target user/role and usage context reference;
+- client/host/platform, input method and relevant size classes;
+- owning Surface/Screen duty and main-versus-drilldown boundary;
+- primary task outcome, primary work object and shortest task loop;
+- material operation–affected-object–feedback relationships; and
+- critical context, state, recovery and accessibility constraints.
+
+These product and surface facts remain owned by controlling Product/Surface/Screen Source. The commission references them without becoming their owner. Separately consume `DESIGN.md` and selected exact-target/constraint Source for visual-system and selected-design conditions. Non-authoritative task-level UI/UX analysis may inform candidate comparison but cannot supply missing product or surface meaning. A feature list, screenshot, route tree, component inventory or analysis output cannot fill a missing product or surface fact; if the missing meaning materially changes the resource, return `decision-required` or request the owning Source update before Provider execution.
+
+If the desired candidate changes durable product goals/rules/capability, page duty, primary work object/task loop, information/action/feedback placement, interaction topology, Design Authority, tokens or component-family grammar, stop and route the change to the actual Product/Surface/Screen/Design owner. Reread the updated owner before resuming selection or generation. A candidate execution defect stays within DRA and does not by itself justify a durable owner change.
+
 ## 2. Choose the intent
 
 | Intent | User decision being supported | Default stopping point |
@@ -44,6 +59,35 @@ Preserve each supplied item's actual role:
 
 An optional pre-existing planning document is one possible input. Raw notes or an initial proposal are equally valid. Never require a special intermediary format merely to make another input usable.
 
+### Pre-generation style-application closure
+
+Before every style-bearing Provider generation or material revision—including a simple high-fidelity preview—evaluate every current-slice style-application dimension which can materially change the output. Reuse the Provider reference's existing material-revision definition; do not create another revision classification. This closure does not apply to non-fidelity work, pure IA/flow topology, low-fidelity structure, a semantics-only state study, a read which starts no new generation, or packaging, renaming or byte-only export proved equivalent to the same canonical source.
+
+At minimum evaluate `primary_content_priority`, `density`, `container_treatment`, `visible_vs_hit_geometry`, `preserve` and `prohibited_patterns`, plus any other obvious slice-specific style-application dimension which materially affects Provider output. These are task-local judgments, not a fixed visual-property matrix or a copy of the formal handoff Fact Universe. Every applicable dimension has exactly one of these dispositions:
+
+| Disposition | Legal condition | Commission representation | Provider effect |
+| --- | --- | --- | --- |
+| `existing-covered` | Current controlling Source or a selected `exact-target`/`constraint` completely governs the exact target, slice and declared conditions and reaches the Provider through an existing input binding | Keep that Source in its existing input binding; do not duplicate it in `style_application` | Contributes to a closed commission |
+| `projected` | Current controlling Source and Design Authority already determine the slice-specific application, but selected input does not directly and completely express it | Put only the necessary current-slice field in the existing `style_application` envelope | Contributes to a closed commission |
+| `not-applicable` | The dimension has no material effect on this resource and the task-local reason is explicit | Keep the reason task-local; emit no empty or placeholder field | Contributes to a closed commission |
+| `decision-required` | Source is missing, stale, conflicting or ambiguous; a user choice is needed; delegation is insufficient; or resolution requires a durable owner change | Give the concrete natural-language reason through the existing disposition; emit no invented application meaning | Blocks the Provider run |
+
+Use `existing-covered` only when all of the following hold:
+
+1. current controlling Source or a selected `exact-target`/`constraint` explicitly specifies the dimension;
+2. the specification applies to the exact target, slice and declared conditions;
+3. the Source remains current after any owner update;
+4. the Provider commission actually carries it through existing `inputs.exact_targets`, `inputs.constraints` or the corresponding current input binding; and
+5. the conclusion requires no Agent inference from a generic style, name or visual impression.
+
+Design System identity, generic Tokens, “follow the design system”, inspiration, background, an unselected candidate, Provider output, a default-only static screenshot and current-implementation evidence do not by themselves establish `existing-covered`. Current implementation may support `preserve` only when controlling Source explicitly makes the observed behavior or visual fact a preservation constraint. A Provider must not infer missing application meaning from any of these inputs, a feature list, route tree, component inventory or task-level UI/UX analysis.
+
+For `projected`, derive only meaning already authorized by current Source and Design Authority. Do not invent product, business, interaction or design-system semantics, paste complete Tokens, copy a Provider prompt or create a persistent Projection. The actual commission envelope contains exactly the `projected` fields: omit `existing-covered` fields, keep `not-applicable` reasons task-local and never encode `decision-required` as a placeholder.
+
+The Provider run is allowed if and only if every applicable dimension is `existing-covered`, `projected` or `not-applicable`. Any `decision-required`, undispositioned dimension or Source conflict blocks commission submission and Provider execution. When resolution changes durable Product/Surface/Screen/Design meaning, use the existing owner-first route above, reread current Source and repeat this closure before resuming DRA. Post-generation Design suitability cannot retroactively repair a commission which skipped this closure.
+
+This judgment occurs inside the existing Source read and commission-envelope action. For a simple high-fidelity preview it adds no Provider generation, tool action, file, checkpoint, persistent state, fixed user pause, required extra conversation turn, formal handoff, manifest, bundle, preflight or complete Fact Universe. When all dimensions close, the same turn may still generate, perform minimal sanity/suitability review, show the candidate and receive a user choice. “Closure required” never means “emit a closure record.”
+
 ## 4. Derive development-corresponding coverage
 
 For an implementation handoff, use this task-local equation:
@@ -56,6 +100,8 @@ resources to commission
 
 A decision is material when changing it would materially change what the user sees, understands, can do or receives as feedback. Pure code structure and non-user-visible implementation choices are not design gaps.
 
+For each selected existing mapping, also name the applicable target/conditions and the meaning that must be preserved. Preservation includes current product/surface meaning, exact resource-owned visual facts, state/condition coverage and component-family or Design-System lineage which the requested change does not authorize altering. Do not treat an unchanged-looking default frame as proof that its hidden states, responsive variants or inherited dependencies are preserved.
+
 Account for the applicable meaning at each level; do not require filler for non-applicable dimensions:
 
 | Coverage level | Material UI/UX meaning |
@@ -73,8 +119,12 @@ For every material in-scope item, record one task-local disposition: `existing-c
 
 Existing coverage is sufficient only for the conditions it explicitly specifies or demonstrates. Seeing a control in one default page frame does not cover its variants, dynamic states, feedback, motion, responsive behavior or accessibility. Conversely, a selected component source may cover many control instances, so do not commission duplicate designs merely because several stable control keys map to it.
 
+Impact assurance has two strengths. A material/recoverable loop may use the complete current `audit_expectations`, bidirectional resource bindings, explicitly unchanged universe, blast-radius universe and inactive-Delta leakage catalog owned by [recovery-and-writeback.md](recovery-and-writeback.md). An ordinary loop without those complete bindings performs only conservative impact analysis from readable Source: mark the unverified remainder, conservatively regenerate within the ceiling or return `decision-required`. Never claim that only identified resources are affected, and never expand outside the ceiling for safety.
+
 Design resources express user-visible interaction semantics and the presentation of product rules. Business, data, permission and algorithmic rules remain owned by product/technical Source; reference those rules and show their visible consequences without inventing them or making a visual artifact their sole owner.
 
+For a Web/App implementation handoff, visual coverage alone is insufficient. Read [implementation-feasibility.md](implementation-feasibility.md) and inspect the current platform, framework/runtime, UI system, token/theming adapter, component owners and route owners. Every material component-family × target × condition profile needs a Source-backed candidate realization or blocker before formal publication. This does not make implementation structure a design decision or put exact design values into technical Source.
+
 ### Formal selected Web/App handoff
 
 When—and only when—the direction is final-selected for a formal Web/App implementation handoff, load [formal-selected-web-app-handoff.md](formal-selected-web-app-handoff.md). That reference owns the complete atomic Expected Fact Universe, canonical acquisition, Inspector/Census, Fact × method proof and publication rules. Exploration never loads or approximates them.
@@ -138,15 +188,40 @@ coverage:
   material_needs: []
   observable_fact_families: []
   existing_mappings: []
+  preserve: []
   required_content_visual: []
   required_components_states: []
   required_interactions_motion: []
   required_adaptation_accessibility: []
 inputs:
+  product_surface_constraints: []
+  technical_sources: []
   exact_targets: []
   constraints: []
   inspiration: []
   background: []
+style_application:
+  primary_content_priority: results-table-is-primary-work-object
+  density: compact-working-density-for-results-table
+  container_treatment: one-flat-table-surface-without-card-wrapper
+  preserve: [selected-header-hierarchy]
+  prohibited_patterns: [nested-cards-around-the-primary-results-table]
+quality_commission:
+  artifact_archetype: dashboard-data-workbench
+  primary_design_challenges: [task-hierarchy, component-reuse, dense-data-legibility]
+  visual_character:
+    desired: [calm, precise, product-specific]
+    avoid: [generic-ai-gradient, excessive-cards, arbitrary-glow]
+  content:
+    real_copy_required: true
+    realistic_data_required: true
+    placeholder_final_content_forbidden: true
+  reference_roles:
+    - { ref: selected-density-reference, role: information-density }
+  component_authoring:
+    shared_families_required: true
+    repeated_instance_specific_styling_forbidden_by_design: true
+  substrate_input_refs: [dashboard-web-feasibility]
 selected_capability:
   kind: runtime-discovered-kind
   id: runtime-discovered-id
@@ -154,17 +229,19 @@ expected_entry: known-or-provider-native
 review_promise: minimal-sanity | handoff-checks | selected-source-snapshot
 ```
 
-This is an explanatory shape, not a required file or schema. Never paste or paraphrase the Open Design capability's own seed/template prompt into it.
+This is an explanatory shape, not a required file or schema; its concrete dashboard values illustrate Source-derived content and are not defaults. Include `style_application` only when material to a style-bearing commission and bind its actual values to current Design Authority, selected Source and the explicit slice. It is not a persisted Application Projection, Authority, state or acceptance record. For style-bearing generation, add an archetype-specific `quality_commission`: name the main design challenges, desired/avoided visual character, real-content obligations, the distinct role of each selected reference, design-side shared-family expectations and applicable feasibility Source. Omit irrelevant keys instead of emitting placeholders.
+
+`repeated_instance_specific_styling_forbidden_by_design` means repeated controls in the selected resource share one component-family grammar rather than being drawn as unrelated instances. It does not assert that later production code already reuses one component. `quality_commission` is Provider input, not a persisted quality score, Authority, Gate, routing record or acceptance result. A simple high-fidelity preview does not gain another tool action or persisted side effect from these fields. Never paste or paraphrase the Open Design capability's own seed/template prompt into it.
 
 ## 9. Iterate and stop
 
-- Keep each revision inside the original scope ceiling unless the user explicitly expands it.
+- Keep each revision inside the original scope ceiling unless the user explicitly expands it; otherwise use `decision-required` with reason `scope-expansion-required`.
 - Reuse the current Open Design project when that preserves context and provenance; preserve the prior artifact hash before overwriting a selected candidate.
 - Do not create low-fi, high-fi, component boards or native-platform copies merely because a process diagram lists them.
 - For exploration, stop as soon as the requested decision is supported.
 - For a final-selected formal Web/App implementation handoff, apply the dedicated formal reference's exact stop conditions. Honest `decision_required`, `unavailable` or capability gaps remain blocking; they cannot be called ready or authorize fidelity work.
 
-During simple iteration, keep accepted, rejected and unresolved implications in a task-local delta buffer. Do not require or emit an interim delta after every iteration and never continuously synchronize the initial proposal. If the loop requires durable semantic replay, a selected-Proposal file writeback or cross-interruption recovery, load [recovery-and-writeback.md](recovery-and-writeback.md) and use its independent origin/decision-authority/evidence/status model plus package helper; prompt prose alone cannot establish CAS or deterministic recovery. After explicit human selection or explicitly delegated selection, consolidate the buffer once and reconcile only accepted decisions into the initial proposal. If it exists only in conversation and safe materialization was not explicitly authorized, return one complete revised proposal and report cross-session deterministic recovery unavailable. Never create another intermediary planning document or mutate Context, `DESIGN.md`, code, tests or Contract.
+During simple iteration, keep accepted, rejected and unresolved implications in a task-local delta buffer. Do not require or emit an interim delta after every iteration and never continuously synchronize the initial proposal. If the loop requires durable semantic replay, a selected-Proposal file writeback or cross-interruption recovery, load [recovery-and-writeback.md](recovery-and-writeback.md) and use its independent origin/decision-authority/evidence/status model plus package helper; prompt prose alone cannot establish CAS or deterministic recovery. Ordinary conversational selection creates no approval record or deterministic cross-session promise; if it is lost before authorized materialization, reconfirm it. For a non-formal small request, explicit human selection or explicitly delegated selection may be consolidated and reconciled once in the same turn. For a selected formal Web/App handoff, defer reconciliation until the formal owner completes canonical closure and no newly visible decision returns to review. Reconcile only accepted decisions. If the Proposal exists only in conversation and safe materialization was not explicitly authorized, return one complete revised proposal and report cross-session deterministic recovery unavailable. Never create another intermediary planning document or mutate Context, `DESIGN.md`, code, tests or Contract.
 
 ## Worked scope examples
 
@@ -176,3 +253,38 @@ During simple iteration, keep accepted, rejected and unresolved implications in
 - **Three-screen interaction flow:** select a low-fi flow and an interactive high-fi prototype only if topology and interaction/visual behavior are independently unresolved.
 - **Local style fix with exact target:** select no new design resource and route to implementation.
 - **Initial proposal before execution:** iterate only requested candidates, keep one task-local delta buffer, then after selection reconcile accepted decisions once. Pass the revised proposal plus selected immutable resources directly to the default Goal or `long-task-workflow`.
+
+### Style-application worked examples
+
+#### Example A — must block
+
+A one-page high-fidelity preview has configured Design Authority but only generic Tokens. No selected `exact-target` or `constraint` specifies the page's primary-content priority, density or container treatment, and the commission has no corresponding projected fields. Generic system binding cannot fill those application decisions. Result: use the existing `decision-required` with concrete missing-Source reasons; the Provider run must not start.
+
+#### Example B — complete existing coverage may omit projection
+
+A local style-bearing revision has a current selected `exact-target` which explicitly specifies every applicable style-application dimension for the exact target and conditions, and that Source is carried through the Provider's existing exact-target input binding. Every dimension is `existing-covered`. Result: omit `style_application` rather than copying the Source, and allow the Provider run.
+
+#### Example C — mixed closure projects only the gaps
+
+The task-local dispositions are:
+
+```text
+primary_content_priority: existing-covered
+density: projected
+container_treatment: projected
+visible_vs_hit_geometry: not-applicable
+preserve: existing-covered
+prohibited_patterns: projected
+```
+
+Assume current Screen Source says the results table is the page's primary work object, current Design Authority calls for compact working density, and an adopted constraint forbids nested cards. The illustrative actual envelope contains only those three Source-derived fields:
+
+```yaml
+style_application:
+  density: compact-working-density-for-results-table
+  container_treatment: one-flat-table-surface-without-card-wrapper
+  prohibited_patterns:
+    - nested-cards-around-the-primary-results-table
+```
+
+All applicable dimensions are closed, so the Provider run is allowed. If any one of them instead becomes unresolved, stale or conflicting, its disposition becomes `decision-required` and the run is blocked.

package/dist/commands/design-resource.js

@@ -29,9 +29,15 @@ export async function designResource(args) {
         process.stdout.write(canonicalJson(result));
         return;
     }
-    console.log(`Design resource handoff ready: ${result.handoff_path}`);
+    console.log(`Design resource handoff preflight valid: ${result.handoff_path}`);
+    console.log("Input closure: valid");
     console.log(`Scope: ${result.handoff.scope.key}`);
     console.log(`Targets: ${result.handoff.targets.map((item) => item.key).join(", ")}`);
+    console.log(`Technical feasibility inputs: ${result.technical_feasibility_identities.length}`);
+    console.log(`Technical feasibility cells: ${result.technical_feasibility_identities.reduce((total, item) => total + item.component_family_cells, 0)}`);
+    console.log(`Technical feasibility blockers: ${result.technical_feasibility_identities.reduce((total, item) => total + item.blockers, 0)}`);
+    console.log(`Limitations: ${result.limitations.length ? result.limitations.join("; ") : "none"}`);
+    console.log("Production conformance: not evaluated");
     if ("metrics" in result) {
         console.log(`Coverage: ${result.manifest.subjects.length} subjects x ${result.manifest.properties.length} atomic properties (${result.rule_projections.length} symbolic Rules)`);
         console.log(`Symbolic: ${result.metrics.semantic_obligations} semantic obligations, ${result.metrics.certificate_obligations} certificates, ${result.metrics.canonical_dag_nodes} DAG nodes, ${result.metrics.canonical_bytes} bytes`);
@@ -88,7 +94,8 @@ async function bundle(args) {
         process.stdout.write(canonicalJson(result));
         return;
     }
-    console.log(`Design resource handoff bundle published: ${result.output_directory}`);
+    console.log(`Design resource Source bundle published: ${result.output_directory}`);
+    console.log("Production readiness: not evaluated");
     console.log(`Handoffs: ${result.handoffs.length}`);
     console.log(`Targets: ${result.handoffs.map((item) => item.target_key).join(", ")}`);
 }

package/dist/index.d.ts

@@ -10,4 +10,4 @@ export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
 export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
 export { closeDeliveryTask, type DeliveryStatusV2, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
 export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";
-export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, CheckExecutionResultV2, CompiledDeliveryContractV2, DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, DesignResourceHandoffPreflightV1, DesignResourceHandoffPreflightV2, DesignResourceHandoffV1, DesignResourceHandoffV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./public-types.js";
+export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, CheckExecutionResultV2, CompiledDeliveryContractV2, DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, DesignResourceHandoffPreflightV1, DesignResourceHandoffPreflightV2, DesignResourceHandoffV1, DesignResourceHandoffV2, DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./public-types.js";

package/dist/lib/design-resource-handoff-bundle.js

@@ -43,6 +43,11 @@ export async function publishDesignResourceHandoffBundle(options) {
             if (!declaredManifestPaths.has(manifestResource.path))
                 invalid("target_manifest_not_declared", `${declaredTarget.key}:${manifestResource.path}`);
             const preflight = await preflightParsedDesignResourceHandoff(repository, parsed);
+            const publishedTarget = preflight.handoff.targets[0];
+            if ((publishedTarget.source_profile.kind === "implementation_web" ||
+                publishedTarget.source_profile.kind === "implementation_app") &&
+                preflight.technical_feasibility_identities.length !== 1)
+                invalid("implementation_feasibility_input_required", `${publishedTarget.key}:${preflight.technical_feasibility_identities.length}`);
             handoffSetIntegrity.consume(preflight);
             const targetKey = preflight.handoff.targets[0].key;
             if (seenTargets.has(targetKey))

package/dist/lib/design-resource-handoff-input-types.d.ts

@@ -1,6 +1,6 @@
 import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 import type { DesignResourceHandoffV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
-export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
+export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "technical_feasibility_inputs" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
     representation: "manifest_backed";
 };
 export type DesignResourceHandoffInputV1 = DesignResourceHandoffV1 | DesignResourceHandoffManifestBackedV1;

package/dist/lib/design-resource-handoff-manifest-projection.js

@@ -11,6 +11,7 @@ export function hydrateManifestBackedDesignResourceHandoff(descriptor, manifests
         intent: descriptor.intent,
         scope: descriptor.scope,
         provenance: descriptor.provenance,
+        technical_feasibility_inputs: descriptor.technical_feasibility_inputs,
         resources: descriptor.resources,
         axis_dispositions: manifest.axis_dispositions,
         condition_exclusions: manifest.condition_exclusions,

package/dist/lib/design-resource-handoff-set-integrity.js

@@ -35,6 +35,7 @@ export function createDesignResourceHandoffSetIntegrity(fail) {
             sharedHeader(scope, "provenance", handoff.provenance);
             sharedHeader(scope, "proposal", handoff.proposal);
             sharedCollection(scope, "resources", handoff.resources);
+            sharedCollection(scope, "technical_feasibility_inputs", handoff.technical_feasibility_inputs);
             sharedCollection(scope, "conditions", handoff.conditions);
             sharedCollection(scope, "properties", handoff.properties);
             sharedCollection(scope, "resource_fact_closure", handoff.resource_fact_closure);

package/dist/lib/design-resource-handoff-shape.js

@@ -1,4 +1,5 @@
 import { parseDesignResourceSymbolicHandoffShape } from "./design-resource-symbolic-fact-shape.js";
+import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.js";
 import { parseDesignResourceAssetBindings, parseDesignResourceAxisDispositions, parseDesignResourceConditionExclusions, parseDesignResourceEnvironments, parseDesignResourceFactCells, parseDesignResourceLineageNodes, parseDesignResourceOracles, parseDesignResourceProofObligations, parseDesignResourceProperties, parseDesignResourceVariationAxisDispositions, parseDesignResourceVariationExclusions, parseDesignResourceVariations, } from "./design-resource-fact-manifest-shape.js";
 import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, parseDesignResourceHandoffResourceFactClosure, } from "./design-resource-handoff-shape-evidence.js";
 import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
@@ -49,7 +50,7 @@ export function parseDesignResourceHandoffShape(value) {
         "coverage",
         "acceptance_blockers",
         "proposal",
-    ]);
+    ], ["technical_feasibility_inputs"]);
     const scope = object(root.scope, "design_resource_handoff.scope", [
         "key",
         "style_dependency",
@@ -92,6 +93,7 @@ export function parseDesignResourceHandoffShape(value) {
             model: string(provenance.model, "design_resource_handoff.provenance.model"),
             design_system_id: string(provenance.design_system_id, "design_resource_handoff.provenance.design_system_id"),
         },
+        technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? []),
         resources: parseDesignResourceHandoffResources(root.resources),
         axis_dispositions: parseDesignResourceAxisDispositions(root.axis_dispositions),
         condition_exclusions: parseDesignResourceConditionExclusions(root.condition_exclusions),
@@ -132,12 +134,13 @@ function parseManifestBackedDesignResourceHandoffShape(value) {
         "resource_fact_closure",
         "coverage",
         "proposal",
-    ]);
+    ], ["technical_feasibility_inputs"]);
     const parsed = parseDesignResourceHandoffShape({
         schema_version: root.schema_version,
         intent: root.intent,
         scope: root.scope,
         provenance: root.provenance,
+        technical_feasibility_inputs: root.technical_feasibility_inputs ?? [],
         resources: root.resources,
         axis_dispositions: [],
         condition_exclusions: [],
@@ -167,6 +170,7 @@ function parseManifestBackedDesignResourceHandoffShape(value) {
         intent: parsed.intent,
         scope: parsed.scope,
         provenance: parsed.provenance,
+        technical_feasibility_inputs: parsed.technical_feasibility_inputs,
         resources: parsed.resources,
         targets: parsed.targets,
         resource_fact_closure: parsed.resource_fact_closure,

package/dist/lib/design-resource-handoff-types.d.ts

@@ -1,5 +1,6 @@
 import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 import type { DesignResourceAssetBindingV1, DesignResourceAxisDispositionV1, DesignResourceConditionCombinationDispositionV1, DesignResourceEnvironmentV1, DesignResourceFactCellV1, DesignResourceFactV1, DesignResourceLineageNodeV1, DesignResourceManifestCollectionName, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1, DesignResourceProofObligationV1, DesignResourceRelationEndpointV1, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceSubjectVariationV1, DesignResourceVariationAxisDispositionV1, DesignResourceVariationCombinationDispositionV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
 export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
 export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
 export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation", "localization_spec", "system_ui_spec", "haptic_spec", "sound_spec", "sound_capture", "render_environment", "relation_spec"];
@@ -30,6 +31,7 @@ export interface DesignResourceHandoffV1 {
         model: string;
         design_system_id: string;
     };
+    technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     axis_dispositions: DesignResourceAxisDispositionV1[];
     condition_exclusions: DesignResourceConditionCombinationDispositionV1[];
@@ -220,6 +222,9 @@ export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHa
     schema_version: "design-resource-handoff-preflight-v1";
     status: "ready";
     resource_hashes: Record<string, string>;
+    technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];
+    technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];
+    limitations: string[];
     manifest_identities: Array<{
         resource_ref: string;
         path: string;

package/dist/lib/design-resource-handoff-validation.js

@@ -12,6 +12,8 @@ import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonempty
 import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { assertDesignResourceV1HandoffCapacity } from "./design-resource-v1-capacity.js";
+import { createV1ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
 export async function preflightDesignResourceHandoff(repository, handoffPath) {
     const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
     await assertDesignResourceV1HandoffCapacity(handoffFile);
@@ -46,11 +48,21 @@ export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     validateDesignResourceFiles(normalized, snapshot.contents);
     validateDesignResourceFactManifests(normalized, snapshot.contents, manifests, !isManifestBacked(inputHandoff));
     const resources = new Map(handoff.resources.map((resource) => [resource.key, resource]));
+    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map(handoff.targets.map((target) => [
+        target.key,
+        createV1ImplementationFeasibilityTargetModel(handoff, target),
+    ])), new Set(handoff.resources.map((resource) => resource.path)));
     return {
         schema_version: "design-resource-handoff-preflight-v1",
         status: "ready",
         ...normalized,
         resource_hashes: snapshot.hashes,
+        technical_feasibility_documents: feasibility.map((item) => item.document),
+        technical_feasibility_identities: feasibility.map((item) => item.identity),
+        limitations: handoff.targets.some((target) => target.source_profile.kind !== "reference" &&
+            !feasibility.some((item) => item.index.target_ref === target.key))
+            ? ["technical feasibility not declared"]
+            : [],
         manifest_identities: handoff.targets.map((target) => {
             const resourceRef = target.source_profile.fact_manifest_resource_ref;
             const resource = resources.get(resourceRef);

package/dist/lib/design-resource-implementation-feasibility-model.d.ts

@@ -0,0 +1,35 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicHandoffTargetV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+interface FeasibilityTargetModelBase {
+    target_ref: string;
+    source_profile_kind: "implementation_web" | "implementation_app" | "reference";
+    component_family_refs: string[];
+    component_family_subject_refs: Map<string, Set<string>>;
+}
+export interface DesignResourceImplementationFeasibilityV1TargetModel extends FeasibilityTargetModelBase {
+    representation: "fact_cells_v1";
+    condition_refs: string[];
+    facts: Map<string, {
+        target_ref: string;
+        subject_ref: string;
+        condition_ref: string;
+    }>;
+}
+export interface DesignResourceImplementationFeasibilityV2TargetModel extends FeasibilityTargetModelBase {
+    representation: "symbolic_rules_v2";
+    axis_domains: SymbolicDenotationAxisDomain[];
+    reachable_region: SymbolicDenotationPredicate;
+    fact_rules: Map<string, DesignResourceSymbolicFactRuleV2>;
+}
+export type DesignResourceImplementationFeasibilityTargetModel = DesignResourceImplementationFeasibilityV1TargetModel | DesignResourceImplementationFeasibilityV2TargetModel;
+export declare function createV1ImplementationFeasibilityTargetModel(handoff: DesignResourceHandoffV1, target: DesignResourceHandoffV1["targets"][number]): DesignResourceImplementationFeasibilityV1TargetModel;
+export declare function createV2ImplementationFeasibilityTargetModel(target: DesignResourceSymbolicHandoffTargetV2, manifest: DesignResourceObservableRuleManifestV2): DesignResourceImplementationFeasibilityV2TargetModel;
+export declare function deriveComponentFamilySubjectClosure(familyRefs: string[], subjects: Array<{
+    key: string;
+    family_ref: string | null;
+    parent_ref: string | null;
+    instance_of_ref: string | null;
+    override_of_ref: string | null;
+}>): Map<string, Set<string>>;
+export {};

package/dist/lib/design-resource-implementation-feasibility-model.js

@@ -0,0 +1,62 @@
+export function createV1ImplementationFeasibilityTargetModel(handoff, target) {
+    const componentFamilies = handoff.subjects.filter((subject) => subject.kind === "component_family" &&
+        subject.target_refs.includes(target.key));
+    return {
+        representation: "fact_cells_v1",
+        target_ref: target.key,
+        source_profile_kind: target.source_profile.kind,
+        component_family_refs: componentFamilies.map((subject) => subject.key),
+        component_family_subject_refs: deriveComponentFamilySubjectClosure(componentFamilies.map((subject) => subject.key), handoff.subjects),
+        condition_refs: [...target.condition_refs],
+        facts: new Map(handoff.facts.map((fact) => [
+            fact.key,
+            {
+                target_ref: fact.target_ref,
+                subject_ref: fact.subject_ref,
+                condition_ref: fact.condition_ref,
+            },
+        ])),
+    };
+}
+export function createV2ImplementationFeasibilityTargetModel(target, manifest) {
+    const componentFamilies = manifest.subjects.filter((subject) => subject.kind === "component_family" &&
+        subject.target_refs.includes(target.key));
+    return {
+        representation: "symbolic_rules_v2",
+        target_ref: target.key,
+        source_profile_kind: target.source_profile.kind,
+        component_family_refs: componentFamilies.map((subject) => subject.key),
+        component_family_subject_refs: deriveComponentFamilySubjectClosure(componentFamilies.map((subject) => subject.key), manifest.subjects),
+        axis_domains: manifest.axis_domains,
+        reachable_region: manifest.reachable_region,
+        fact_rules: new Map(manifest.fact_rules.map((rule) => [rule.key, rule])),
+    };
+}
+export function deriveComponentFamilySubjectClosure(familyRefs, subjects) {
+    const result = new Map();
+    for (const familyRef of familyRefs) {
+        const closure = new Set(subjects
+            .filter((subject) => subject.key === familyRef ||
+            subject.family_ref === familyRef ||
+            subject.instance_of_ref === familyRef)
+            .map((subject) => subject.key));
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const subject of subjects) {
+                if (closure.has(subject.key))
+                    continue;
+                if ((subject.parent_ref !== null && closure.has(subject.parent_ref)) ||
+                    (subject.instance_of_ref !== null &&
+                        closure.has(subject.instance_of_ref)) ||
+                    (subject.override_of_ref !== null &&
+                        closure.has(subject.override_of_ref))) {
+                    closure.add(subject.key);
+                    changed = true;
+                }
+            }
+        }
+        result.set(familyRef, closure);
+    }
+    return result;
+}

package/dist/lib/design-resource-implementation-feasibility-shape-sections.d.ts

@@ -0,0 +1,43 @@
+import { type DesignResourceImplementationConditionModelV1 } from "./design-resource-implementation-feasibility-types.js";
+export declare function parseConditionModel(value: unknown, label: string): DesignResourceImplementationConditionModelV1;
+export declare function parseComponentFamilyCells(value: unknown, label: string): {
+    key: string;
+    component_family_ref: string;
+    target_ref: string;
+    condition_profile_ref: string;
+    design_fact_refs: string[];
+    feasible_realizations: {
+        key: string;
+        strategy_steps: ("compose_existing" | "create_shared_component" | "extend_shared_component" | "reuse_existing" | "theme_with_tokens")[];
+        primitive_refs: string[];
+        owner_candidates: ({
+            kind: "existing_path";
+            locator: string;
+            existence: "existing";
+            authorization_source_refs?: undefined;
+        } | {
+            kind: "planned_logical_owner";
+            locator: string;
+            existence: "planned";
+            authorization_source_refs: string[];
+        })[];
+        supported_customization_surfaces: ("behavior_slot" | "component_variant" | "composition" | "content_slot" | "icon_slot" | "primitive_props" | "style_api" | "theme_tokens")[];
+        feasibility_basis_refs: string[];
+        observed_costs: string[];
+        observed_risks: string[];
+    }[];
+    required_realization: {
+        realization_ref: string | null;
+        technical_authority_source_refs: string[];
+    };
+    blocker_refs: string[];
+}[];
+export declare function parseBlockers(value: unknown, label: string): {
+    key: string;
+    component_family_ref: string;
+    target_ref: string;
+    condition_profile_ref: string;
+    source_record_refs: string[];
+    substrate_observation_refs: ("component_owner_roots" | "framework_runtime" | "platform" | "route_owner_roots" | "token_theming_adapter" | "ui_system")[];
+    description: string;
+}[];